daily update
[deliverable/binutils-gdb.git] / bfd / elf.c
CommitLineData
252b5132 1/* ELF executable support for BFD.
340b6d91 2
4b95cf5c 3 Copyright (C) 1993-2014 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"
3db64b00 38#include "bfd.h"
252b5132
RH
39#include "bfdlink.h"
40#include "libbfd.h"
41#define ARCH_SIZE 0
42#include "elf-bfd.h"
e0e8c97f 43#include "libiberty.h"
ff59fc36 44#include "safe-ctype.h"
70a38d42 45#include "elf-linux-psinfo.h"
252b5132 46
8bc7f138
L
47#ifdef CORE_HEADER
48#include CORE_HEADER
49#endif
50
217aa764 51static int elf_sort_sections (const void *, const void *);
c84fca4d 52static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
217aa764
AM
53static bfd_boolean prep_headers (bfd *);
54static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
718175fa
JK
55static bfd_boolean elf_read_notes (bfd *, file_ptr, bfd_size_type) ;
56static bfd_boolean elf_parse_notes (bfd *abfd, char *buf, size_t size,
57 file_ptr offset);
50b2bdb7 58
252b5132
RH
59/* Swap version information in and out. The version information is
60 currently size independent. If that ever changes, this code will
61 need to move into elfcode.h. */
62
63/* Swap in a Verdef structure. */
64
65void
217aa764
AM
66_bfd_elf_swap_verdef_in (bfd *abfd,
67 const Elf_External_Verdef *src,
68 Elf_Internal_Verdef *dst)
252b5132 69{
dc810e39
AM
70 dst->vd_version = H_GET_16 (abfd, src->vd_version);
71 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
72 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
73 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
74 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
75 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
76 dst->vd_next = H_GET_32 (abfd, src->vd_next);
252b5132
RH
77}
78
79/* Swap out a Verdef structure. */
80
81void
217aa764
AM
82_bfd_elf_swap_verdef_out (bfd *abfd,
83 const Elf_Internal_Verdef *src,
84 Elf_External_Verdef *dst)
252b5132 85{
dc810e39
AM
86 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
87 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
88 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
89 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
90 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
91 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
92 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
252b5132
RH
93}
94
95/* Swap in a Verdaux structure. */
96
97void
217aa764
AM
98_bfd_elf_swap_verdaux_in (bfd *abfd,
99 const Elf_External_Verdaux *src,
100 Elf_Internal_Verdaux *dst)
252b5132 101{
dc810e39
AM
102 dst->vda_name = H_GET_32 (abfd, src->vda_name);
103 dst->vda_next = H_GET_32 (abfd, src->vda_next);
252b5132
RH
104}
105
106/* Swap out a Verdaux structure. */
107
108void
217aa764
AM
109_bfd_elf_swap_verdaux_out (bfd *abfd,
110 const Elf_Internal_Verdaux *src,
111 Elf_External_Verdaux *dst)
252b5132 112{
dc810e39
AM
113 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
114 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
252b5132
RH
115}
116
117/* Swap in a Verneed structure. */
118
119void
217aa764
AM
120_bfd_elf_swap_verneed_in (bfd *abfd,
121 const Elf_External_Verneed *src,
122 Elf_Internal_Verneed *dst)
252b5132 123{
dc810e39
AM
124 dst->vn_version = H_GET_16 (abfd, src->vn_version);
125 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
126 dst->vn_file = H_GET_32 (abfd, src->vn_file);
127 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
128 dst->vn_next = H_GET_32 (abfd, src->vn_next);
252b5132
RH
129}
130
131/* Swap out a Verneed structure. */
132
133void
217aa764
AM
134_bfd_elf_swap_verneed_out (bfd *abfd,
135 const Elf_Internal_Verneed *src,
136 Elf_External_Verneed *dst)
252b5132 137{
dc810e39
AM
138 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
139 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
140 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
141 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
142 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
252b5132
RH
143}
144
145/* Swap in a Vernaux structure. */
146
147void
217aa764
AM
148_bfd_elf_swap_vernaux_in (bfd *abfd,
149 const Elf_External_Vernaux *src,
150 Elf_Internal_Vernaux *dst)
252b5132 151{
dc810e39
AM
152 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
153 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
154 dst->vna_other = H_GET_16 (abfd, src->vna_other);
155 dst->vna_name = H_GET_32 (abfd, src->vna_name);
156 dst->vna_next = H_GET_32 (abfd, src->vna_next);
252b5132
RH
157}
158
159/* Swap out a Vernaux structure. */
160
161void
217aa764
AM
162_bfd_elf_swap_vernaux_out (bfd *abfd,
163 const Elf_Internal_Vernaux *src,
164 Elf_External_Vernaux *dst)
252b5132 165{
dc810e39
AM
166 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
167 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
168 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
169 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
170 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
252b5132
RH
171}
172
173/* Swap in a Versym structure. */
174
175void
217aa764
AM
176_bfd_elf_swap_versym_in (bfd *abfd,
177 const Elf_External_Versym *src,
178 Elf_Internal_Versym *dst)
252b5132 179{
dc810e39 180 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
252b5132
RH
181}
182
183/* Swap out a Versym structure. */
184
185void
217aa764
AM
186_bfd_elf_swap_versym_out (bfd *abfd,
187 const Elf_Internal_Versym *src,
188 Elf_External_Versym *dst)
252b5132 189{
dc810e39 190 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
252b5132
RH
191}
192
193/* Standard ELF hash function. Do not change this function; you will
194 cause invalid hash tables to be generated. */
3a99b017 195
252b5132 196unsigned long
217aa764 197bfd_elf_hash (const char *namearg)
252b5132 198{
3a99b017 199 const unsigned char *name = (const unsigned char *) namearg;
252b5132
RH
200 unsigned long h = 0;
201 unsigned long g;
202 int ch;
203
204 while ((ch = *name++) != '\0')
205 {
206 h = (h << 4) + ch;
207 if ((g = (h & 0xf0000000)) != 0)
208 {
209 h ^= g >> 24;
210 /* The ELF ABI says `h &= ~g', but this is equivalent in
211 this case and on some machines one insn instead of two. */
212 h ^= g;
213 }
214 }
32dfa85d 215 return h & 0xffffffff;
252b5132
RH
216}
217
fdc90cb4
JJ
218/* DT_GNU_HASH hash function. Do not change this function; you will
219 cause invalid hash tables to be generated. */
220
221unsigned long
222bfd_elf_gnu_hash (const char *namearg)
223{
224 const unsigned char *name = (const unsigned char *) namearg;
225 unsigned long h = 5381;
226 unsigned char ch;
227
228 while ((ch = *name++) != '\0')
229 h = (h << 5) + h + ch;
230 return h & 0xffffffff;
231}
232
0c8d6e5c
AM
233/* Create a tdata field OBJECT_SIZE bytes in length, zeroed out and with
234 the object_id field of an elf_obj_tdata field set to OBJECT_ID. */
b34976b6 235bfd_boolean
0c8d6e5c 236bfd_elf_allocate_object (bfd *abfd,
0ffa91dd 237 size_t object_size,
4dfe6ac6 238 enum elf_target_id object_id)
252b5132 239{
0ffa91dd
NC
240 BFD_ASSERT (object_size >= sizeof (struct elf_obj_tdata));
241 abfd->tdata.any = bfd_zalloc (abfd, object_size);
242 if (abfd->tdata.any == NULL)
243 return FALSE;
252b5132 244
0ffa91dd 245 elf_object_id (abfd) = object_id;
c0355132
AM
246 if (abfd->direction != read_direction)
247 {
248 struct output_elf_obj_tdata *o = bfd_zalloc (abfd, sizeof *o);
249 if (o == NULL)
250 return FALSE;
251 elf_tdata (abfd)->o = o;
252 elf_program_header_size (abfd) = (bfd_size_type) -1;
253 }
b34976b6 254 return TRUE;
252b5132
RH
255}
256
0ffa91dd
NC
257
258bfd_boolean
ae95ffa6 259bfd_elf_make_object (bfd *abfd)
0ffa91dd 260{
ae95ffa6 261 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
0ffa91dd 262 return bfd_elf_allocate_object (abfd, sizeof (struct elf_obj_tdata),
ae95ffa6 263 bed->target_id);
0ffa91dd
NC
264}
265
b34976b6 266bfd_boolean
217aa764 267bfd_elf_mkcorefile (bfd *abfd)
252b5132 268{
c044fabd 269 /* I think this can be done just like an object file. */
228e534f
AM
270 if (!abfd->xvec->_bfd_set_format[(int) bfd_object] (abfd))
271 return FALSE;
272 elf_tdata (abfd)->core = bfd_zalloc (abfd, sizeof (*elf_tdata (abfd)->core));
273 return elf_tdata (abfd)->core != NULL;
252b5132
RH
274}
275
72a80a16 276static char *
217aa764 277bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
252b5132
RH
278{
279 Elf_Internal_Shdr **i_shdrp;
f075ee0c 280 bfd_byte *shstrtab = NULL;
dc810e39
AM
281 file_ptr offset;
282 bfd_size_type shstrtabsize;
252b5132
RH
283
284 i_shdrp = elf_elfsections (abfd);
74f2e02b
AM
285 if (i_shdrp == 0
286 || shindex >= elf_numsections (abfd)
287 || i_shdrp[shindex] == 0)
f075ee0c 288 return NULL;
252b5132 289
f075ee0c 290 shstrtab = i_shdrp[shindex]->contents;
252b5132
RH
291 if (shstrtab == NULL)
292 {
c044fabd 293 /* No cached one, attempt to read, and cache what we read. */
252b5132
RH
294 offset = i_shdrp[shindex]->sh_offset;
295 shstrtabsize = i_shdrp[shindex]->sh_size;
c6c60d09
JJ
296
297 /* Allocate and clear an extra byte at the end, to prevent crashes
298 in case the string table is not terminated. */
3471d59d 299 if (shstrtabsize + 1 <= 1
a50b1753 300 || (shstrtab = (bfd_byte *) bfd_alloc (abfd, shstrtabsize + 1)) == NULL
c6c60d09
JJ
301 || bfd_seek (abfd, offset, SEEK_SET) != 0)
302 shstrtab = NULL;
303 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
304 {
305 if (bfd_get_error () != bfd_error_system_call)
306 bfd_set_error (bfd_error_file_truncated);
307 shstrtab = NULL;
3471d59d
CC
308 /* Once we've failed to read it, make sure we don't keep
309 trying. Otherwise, we'll keep allocating space for
310 the string table over and over. */
311 i_shdrp[shindex]->sh_size = 0;
c6c60d09
JJ
312 }
313 else
314 shstrtab[shstrtabsize] = '\0';
217aa764 315 i_shdrp[shindex]->contents = shstrtab;
252b5132 316 }
f075ee0c 317 return (char *) shstrtab;
252b5132
RH
318}
319
320char *
217aa764
AM
321bfd_elf_string_from_elf_section (bfd *abfd,
322 unsigned int shindex,
323 unsigned int strindex)
252b5132
RH
324{
325 Elf_Internal_Shdr *hdr;
326
327 if (strindex == 0)
328 return "";
329
74f2e02b
AM
330 if (elf_elfsections (abfd) == NULL || shindex >= elf_numsections (abfd))
331 return NULL;
332
252b5132
RH
333 hdr = elf_elfsections (abfd)[shindex];
334
335 if (hdr->contents == NULL
336 && bfd_elf_get_str_section (abfd, shindex) == NULL)
337 return NULL;
338
339 if (strindex >= hdr->sh_size)
340 {
1b3a8575 341 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
252b5132 342 (*_bfd_error_handler)
d003868e
AM
343 (_("%B: invalid string offset %u >= %lu for section `%s'"),
344 abfd, strindex, (unsigned long) hdr->sh_size,
1b3a8575 345 (shindex == shstrndx && strindex == hdr->sh_name
252b5132 346 ? ".shstrtab"
1b3a8575 347 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
45b222d6 348 return NULL;
252b5132
RH
349 }
350
351 return ((char *) hdr->contents) + strindex;
352}
353
6cdc0ccc
AM
354/* Read and convert symbols to internal format.
355 SYMCOUNT specifies the number of symbols to read, starting from
356 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
357 are non-NULL, they are used to store the internal symbols, external
b7c368d0
NC
358 symbols, and symbol section index extensions, respectively.
359 Returns a pointer to the internal symbol buffer (malloced if necessary)
360 or NULL if there were no symbols or some kind of problem. */
6cdc0ccc
AM
361
362Elf_Internal_Sym *
217aa764
AM
363bfd_elf_get_elf_syms (bfd *ibfd,
364 Elf_Internal_Shdr *symtab_hdr,
365 size_t symcount,
366 size_t symoffset,
367 Elf_Internal_Sym *intsym_buf,
368 void *extsym_buf,
369 Elf_External_Sym_Shndx *extshndx_buf)
6cdc0ccc
AM
370{
371 Elf_Internal_Shdr *shndx_hdr;
217aa764 372 void *alloc_ext;
df622259 373 const bfd_byte *esym;
6cdc0ccc
AM
374 Elf_External_Sym_Shndx *alloc_extshndx;
375 Elf_External_Sym_Shndx *shndx;
4dd07732 376 Elf_Internal_Sym *alloc_intsym;
6cdc0ccc
AM
377 Elf_Internal_Sym *isym;
378 Elf_Internal_Sym *isymend;
9c5bfbb7 379 const struct elf_backend_data *bed;
6cdc0ccc
AM
380 size_t extsym_size;
381 bfd_size_type amt;
382 file_ptr pos;
383
e44a2c9c
AM
384 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
385 abort ();
386
6cdc0ccc
AM
387 if (symcount == 0)
388 return intsym_buf;
389
390 /* Normal syms might have section extension entries. */
391 shndx_hdr = NULL;
392 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
393 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
394
395 /* Read the symbols. */
396 alloc_ext = NULL;
397 alloc_extshndx = NULL;
4dd07732 398 alloc_intsym = NULL;
6cdc0ccc
AM
399 bed = get_elf_backend_data (ibfd);
400 extsym_size = bed->s->sizeof_sym;
401 amt = symcount * extsym_size;
402 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
403 if (extsym_buf == NULL)
404 {
d0fb9a8d 405 alloc_ext = bfd_malloc2 (symcount, extsym_size);
6cdc0ccc
AM
406 extsym_buf = alloc_ext;
407 }
408 if (extsym_buf == NULL
409 || bfd_seek (ibfd, pos, SEEK_SET) != 0
410 || bfd_bread (extsym_buf, amt, ibfd) != amt)
411 {
412 intsym_buf = NULL;
413 goto out;
414 }
415
416 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
417 extshndx_buf = NULL;
418 else
419 {
420 amt = symcount * sizeof (Elf_External_Sym_Shndx);
421 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
422 if (extshndx_buf == NULL)
423 {
a50b1753
NC
424 alloc_extshndx = (Elf_External_Sym_Shndx *)
425 bfd_malloc2 (symcount, sizeof (Elf_External_Sym_Shndx));
6cdc0ccc
AM
426 extshndx_buf = alloc_extshndx;
427 }
428 if (extshndx_buf == NULL
429 || bfd_seek (ibfd, pos, SEEK_SET) != 0
430 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
431 {
432 intsym_buf = NULL;
433 goto out;
434 }
435 }
436
437 if (intsym_buf == NULL)
438 {
a50b1753
NC
439 alloc_intsym = (Elf_Internal_Sym *)
440 bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
4dd07732 441 intsym_buf = alloc_intsym;
6cdc0ccc
AM
442 if (intsym_buf == NULL)
443 goto out;
444 }
445
446 /* Convert the symbols to internal form. */
447 isymend = intsym_buf + symcount;
a50b1753
NC
448 for (esym = (const bfd_byte *) extsym_buf, isym = intsym_buf,
449 shndx = extshndx_buf;
6cdc0ccc
AM
450 isym < isymend;
451 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
8384fb8f
AM
452 if (!(*bed->s->swap_symbol_in) (ibfd, esym, shndx, isym))
453 {
454 symoffset += (esym - (bfd_byte *) extsym_buf) / extsym_size;
455 (*_bfd_error_handler) (_("%B symbol number %lu references "
456 "nonexistent SHT_SYMTAB_SHNDX section"),
457 ibfd, (unsigned long) symoffset);
4dd07732
AM
458 if (alloc_intsym != NULL)
459 free (alloc_intsym);
8384fb8f
AM
460 intsym_buf = NULL;
461 goto out;
462 }
6cdc0ccc
AM
463
464 out:
465 if (alloc_ext != NULL)
466 free (alloc_ext);
467 if (alloc_extshndx != NULL)
468 free (alloc_extshndx);
469
470 return intsym_buf;
471}
472
5cab59f6
AM
473/* Look up a symbol name. */
474const char *
be8dd2ca
AM
475bfd_elf_sym_name (bfd *abfd,
476 Elf_Internal_Shdr *symtab_hdr,
26c61ae5
L
477 Elf_Internal_Sym *isym,
478 asection *sym_sec)
5cab59f6 479{
26c61ae5 480 const char *name;
5cab59f6 481 unsigned int iname = isym->st_name;
be8dd2ca 482 unsigned int shindex = symtab_hdr->sh_link;
26c61ae5 483
138f35cc
JJ
484 if (iname == 0 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
485 /* Check for a bogus st_shndx to avoid crashing. */
4fbb74a6 486 && isym->st_shndx < elf_numsections (abfd))
5cab59f6
AM
487 {
488 iname = elf_elfsections (abfd)[isym->st_shndx]->sh_name;
489 shindex = elf_elfheader (abfd)->e_shstrndx;
490 }
491
26c61ae5
L
492 name = bfd_elf_string_from_elf_section (abfd, shindex, iname);
493 if (name == NULL)
494 name = "(null)";
495 else if (sym_sec && *name == '\0')
496 name = bfd_section_name (abfd, sym_sec);
497
498 return name;
5cab59f6
AM
499}
500
dbb410c3
AM
501/* Elf_Internal_Shdr->contents is an array of these for SHT_GROUP
502 sections. The first element is the flags, the rest are section
503 pointers. */
504
505typedef union elf_internal_group {
506 Elf_Internal_Shdr *shdr;
507 unsigned int flags;
508} Elf_Internal_Group;
509
b885599b
AM
510/* Return the name of the group signature symbol. Why isn't the
511 signature just a string? */
512
513static const char *
217aa764 514group_signature (bfd *abfd, Elf_Internal_Shdr *ghdr)
b885599b 515{
9dce4196 516 Elf_Internal_Shdr *hdr;
9dce4196
AM
517 unsigned char esym[sizeof (Elf64_External_Sym)];
518 Elf_External_Sym_Shndx eshndx;
519 Elf_Internal_Sym isym;
b885599b 520
13792e9d
L
521 /* First we need to ensure the symbol table is available. Make sure
522 that it is a symbol table section. */
4fbb74a6
AM
523 if (ghdr->sh_link >= elf_numsections (abfd))
524 return NULL;
13792e9d
L
525 hdr = elf_elfsections (abfd) [ghdr->sh_link];
526 if (hdr->sh_type != SHT_SYMTAB
527 || ! bfd_section_from_shdr (abfd, ghdr->sh_link))
b885599b
AM
528 return NULL;
529
9dce4196
AM
530 /* Go read the symbol. */
531 hdr = &elf_tdata (abfd)->symtab_hdr;
6cdc0ccc
AM
532 if (bfd_elf_get_elf_syms (abfd, hdr, 1, ghdr->sh_info,
533 &isym, esym, &eshndx) == NULL)
b885599b 534 return NULL;
9dce4196 535
26c61ae5 536 return bfd_elf_sym_name (abfd, hdr, &isym, NULL);
b885599b
AM
537}
538
dbb410c3
AM
539/* Set next_in_group list pointer, and group name for NEWSECT. */
540
b34976b6 541static bfd_boolean
217aa764 542setup_group (bfd *abfd, Elf_Internal_Shdr *hdr, asection *newsect)
dbb410c3
AM
543{
544 unsigned int num_group = elf_tdata (abfd)->num_group;
545
546 /* If num_group is zero, read in all SHT_GROUP sections. The count
547 is set to -1 if there are no SHT_GROUP sections. */
548 if (num_group == 0)
549 {
550 unsigned int i, shnum;
551
552 /* First count the number of groups. If we have a SHT_GROUP
553 section with just a flag word (ie. sh_size is 4), ignore it. */
9ad5cbcf 554 shnum = elf_numsections (abfd);
dbb410c3 555 num_group = 0;
08a40648 556
44534af3 557#define IS_VALID_GROUP_SECTION_HEADER(shdr, minsize) \
1783205a 558 ( (shdr)->sh_type == SHT_GROUP \
44534af3 559 && (shdr)->sh_size >= minsize \
1783205a
NC
560 && (shdr)->sh_entsize == GRP_ENTRY_SIZE \
561 && ((shdr)->sh_size % GRP_ENTRY_SIZE) == 0)
08a40648 562
dbb410c3
AM
563 for (i = 0; i < shnum; i++)
564 {
565 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
1783205a 566
44534af3 567 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
dbb410c3
AM
568 num_group += 1;
569 }
570
571 if (num_group == 0)
20dbb49d
L
572 {
573 num_group = (unsigned) -1;
574 elf_tdata (abfd)->num_group = num_group;
575 }
576 else
dbb410c3
AM
577 {
578 /* We keep a list of elf section headers for group sections,
579 so we can find them quickly. */
20dbb49d 580 bfd_size_type amt;
d0fb9a8d 581
20dbb49d 582 elf_tdata (abfd)->num_group = num_group;
a50b1753
NC
583 elf_tdata (abfd)->group_sect_ptr = (Elf_Internal_Shdr **)
584 bfd_alloc2 (abfd, num_group, sizeof (Elf_Internal_Shdr *));
dbb410c3 585 if (elf_tdata (abfd)->group_sect_ptr == NULL)
b34976b6 586 return FALSE;
dbb410c3
AM
587
588 num_group = 0;
589 for (i = 0; i < shnum; i++)
590 {
591 Elf_Internal_Shdr *shdr = elf_elfsections (abfd)[i];
1783205a 592
44534af3 593 if (IS_VALID_GROUP_SECTION_HEADER (shdr, 2 * GRP_ENTRY_SIZE))
dbb410c3 594 {
973ffd63 595 unsigned char *src;
dbb410c3
AM
596 Elf_Internal_Group *dest;
597
598 /* Add to list of sections. */
599 elf_tdata (abfd)->group_sect_ptr[num_group] = shdr;
600 num_group += 1;
601
602 /* Read the raw contents. */
603 BFD_ASSERT (sizeof (*dest) >= 4);
604 amt = shdr->sh_size * sizeof (*dest) / 4;
a50b1753
NC
605 shdr->contents = (unsigned char *)
606 bfd_alloc2 (abfd, shdr->sh_size, sizeof (*dest) / 4);
1783205a
NC
607 /* PR binutils/4110: Handle corrupt group headers. */
608 if (shdr->contents == NULL)
609 {
610 _bfd_error_handler
611 (_("%B: Corrupt size field in group section header: 0x%lx"), abfd, shdr->sh_size);
612 bfd_set_error (bfd_error_bad_value);
613 return FALSE;
614 }
615
616 memset (shdr->contents, 0, amt);
617
618 if (bfd_seek (abfd, shdr->sh_offset, SEEK_SET) != 0
dbb410c3
AM
619 || (bfd_bread (shdr->contents, shdr->sh_size, abfd)
620 != shdr->sh_size))
b34976b6 621 return FALSE;
dbb410c3
AM
622
623 /* Translate raw contents, a flag word followed by an
624 array of elf section indices all in target byte order,
625 to the flag word followed by an array of elf section
626 pointers. */
627 src = shdr->contents + shdr->sh_size;
628 dest = (Elf_Internal_Group *) (shdr->contents + amt);
629 while (1)
630 {
631 unsigned int idx;
632
633 src -= 4;
634 --dest;
635 idx = H_GET_32 (abfd, src);
636 if (src == shdr->contents)
637 {
638 dest->flags = idx;
b885599b
AM
639 if (shdr->bfd_section != NULL && (idx & GRP_COMDAT))
640 shdr->bfd_section->flags
641 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
dbb410c3
AM
642 break;
643 }
644 if (idx >= shnum)
645 {
646 ((*_bfd_error_handler)
d003868e 647 (_("%B: invalid SHT_GROUP entry"), abfd));
dbb410c3
AM
648 idx = 0;
649 }
650 dest->shdr = elf_elfsections (abfd)[idx];
651 }
652 }
653 }
654 }
655 }
656
657 if (num_group != (unsigned) -1)
658 {
659 unsigned int i;
660
661 for (i = 0; i < num_group; i++)
662 {
663 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
664 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
665 unsigned int n_elt = shdr->sh_size / 4;
666
667 /* Look through this group's sections to see if current
668 section is a member. */
669 while (--n_elt != 0)
670 if ((++idx)->shdr == hdr)
671 {
e0e8c97f 672 asection *s = NULL;
dbb410c3
AM
673
674 /* We are a member of this group. Go looking through
675 other members to see if any others are linked via
676 next_in_group. */
677 idx = (Elf_Internal_Group *) shdr->contents;
678 n_elt = shdr->sh_size / 4;
679 while (--n_elt != 0)
680 if ((s = (++idx)->shdr->bfd_section) != NULL
945906ff 681 && elf_next_in_group (s) != NULL)
dbb410c3
AM
682 break;
683 if (n_elt != 0)
684 {
dbb410c3
AM
685 /* Snarf the group name from other member, and
686 insert current section in circular list. */
945906ff
AM
687 elf_group_name (newsect) = elf_group_name (s);
688 elf_next_in_group (newsect) = elf_next_in_group (s);
689 elf_next_in_group (s) = newsect;
dbb410c3
AM
690 }
691 else
692 {
dbb410c3
AM
693 const char *gname;
694
b885599b
AM
695 gname = group_signature (abfd, shdr);
696 if (gname == NULL)
b34976b6 697 return FALSE;
945906ff 698 elf_group_name (newsect) = gname;
dbb410c3
AM
699
700 /* Start a circular list with one element. */
945906ff 701 elf_next_in_group (newsect) = newsect;
dbb410c3 702 }
b885599b 703
9dce4196
AM
704 /* If the group section has been created, point to the
705 new member. */
dbb410c3 706 if (shdr->bfd_section != NULL)
945906ff 707 elf_next_in_group (shdr->bfd_section) = newsect;
b885599b 708
dbb410c3
AM
709 i = num_group - 1;
710 break;
711 }
712 }
713 }
714
945906ff 715 if (elf_group_name (newsect) == NULL)
dbb410c3 716 {
d003868e
AM
717 (*_bfd_error_handler) (_("%B: no group info for section %A"),
718 abfd, newsect);
dbb410c3 719 }
b34976b6 720 return TRUE;
dbb410c3
AM
721}
722
3d7f7666 723bfd_boolean
dd863624 724_bfd_elf_setup_sections (bfd *abfd)
3d7f7666
L
725{
726 unsigned int i;
727 unsigned int num_group = elf_tdata (abfd)->num_group;
728 bfd_boolean result = TRUE;
dd863624
L
729 asection *s;
730
731 /* Process SHF_LINK_ORDER. */
732 for (s = abfd->sections; s != NULL; s = s->next)
733 {
734 Elf_Internal_Shdr *this_hdr = &elf_section_data (s)->this_hdr;
735 if ((this_hdr->sh_flags & SHF_LINK_ORDER) != 0)
736 {
737 unsigned int elfsec = this_hdr->sh_link;
738 /* FIXME: The old Intel compiler and old strip/objcopy may
739 not set the sh_link or sh_info fields. Hence we could
740 get the situation where elfsec is 0. */
741 if (elfsec == 0)
742 {
4fbb74a6 743 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
dd863624
L
744 if (bed->link_order_error_handler)
745 bed->link_order_error_handler
746 (_("%B: warning: sh_link not set for section `%A'"),
747 abfd, s);
748 }
749 else
750 {
91d6fa6a 751 asection *linksec = NULL;
25bbc984 752
4fbb74a6
AM
753 if (elfsec < elf_numsections (abfd))
754 {
755 this_hdr = elf_elfsections (abfd)[elfsec];
91d6fa6a 756 linksec = this_hdr->bfd_section;
4fbb74a6 757 }
25bbc984
L
758
759 /* PR 1991, 2008:
760 Some strip/objcopy may leave an incorrect value in
761 sh_link. We don't want to proceed. */
91d6fa6a 762 if (linksec == NULL)
25bbc984
L
763 {
764 (*_bfd_error_handler)
765 (_("%B: sh_link [%d] in section `%A' is incorrect"),
766 s->owner, s, elfsec);
767 result = FALSE;
768 }
769
91d6fa6a 770 elf_linked_to_section (s) = linksec;
dd863624
L
771 }
772 }
773 }
3d7f7666 774
dd863624 775 /* Process section groups. */
3d7f7666
L
776 if (num_group == (unsigned) -1)
777 return result;
778
779 for (i = 0; i < num_group; i++)
780 {
781 Elf_Internal_Shdr *shdr = elf_tdata (abfd)->group_sect_ptr[i];
782 Elf_Internal_Group *idx = (Elf_Internal_Group *) shdr->contents;
783 unsigned int n_elt = shdr->sh_size / 4;
784
785 while (--n_elt != 0)
786 if ((++idx)->shdr->bfd_section)
787 elf_sec_group (idx->shdr->bfd_section) = shdr->bfd_section;
788 else if (idx->shdr->sh_type == SHT_RELA
789 || idx->shdr->sh_type == SHT_REL)
790 /* We won't include relocation sections in section groups in
791 output object files. We adjust the group section size here
792 so that relocatable link will work correctly when
793 relocation sections are in section group in input object
794 files. */
795 shdr->bfd_section->size -= 4;
796 else
797 {
798 /* There are some unknown sections in the group. */
799 (*_bfd_error_handler)
d003868e
AM
800 (_("%B: unknown [%d] section `%s' in group [%s]"),
801 abfd,
3d7f7666 802 (unsigned int) idx->shdr->sh_type,
1b3a8575
AM
803 bfd_elf_string_from_elf_section (abfd,
804 (elf_elfheader (abfd)
805 ->e_shstrndx),
806 idx->shdr->sh_name),
3d7f7666
L
807 shdr->bfd_section->name);
808 result = FALSE;
809 }
810 }
811 return result;
812}
813
72adc230
AM
814bfd_boolean
815bfd_elf_is_group_section (bfd *abfd ATTRIBUTE_UNUSED, const asection *sec)
816{
817 return elf_next_in_group (sec) != NULL;
818}
819
252b5132
RH
820/* Make a BFD section from an ELF section. We store a pointer to the
821 BFD section in the bfd_section field of the header. */
822
b34976b6 823bfd_boolean
217aa764
AM
824_bfd_elf_make_section_from_shdr (bfd *abfd,
825 Elf_Internal_Shdr *hdr,
6dc132d9
L
826 const char *name,
827 int shindex)
252b5132
RH
828{
829 asection *newsect;
830 flagword flags;
9c5bfbb7 831 const struct elf_backend_data *bed;
252b5132
RH
832
833 if (hdr->bfd_section != NULL)
4e011fb5 834 return TRUE;
252b5132
RH
835
836 newsect = bfd_make_section_anyway (abfd, name);
837 if (newsect == NULL)
b34976b6 838 return FALSE;
252b5132 839
1829f4b2
AM
840 hdr->bfd_section = newsect;
841 elf_section_data (newsect)->this_hdr = *hdr;
6dc132d9 842 elf_section_data (newsect)->this_idx = shindex;
1829f4b2 843
2f89ff8d
L
844 /* Always use the real type/flags. */
845 elf_section_type (newsect) = hdr->sh_type;
846 elf_section_flags (newsect) = hdr->sh_flags;
847
252b5132
RH
848 newsect->filepos = hdr->sh_offset;
849
850 if (! bfd_set_section_vma (abfd, newsect, hdr->sh_addr)
851 || ! bfd_set_section_size (abfd, newsect, hdr->sh_size)
852 || ! bfd_set_section_alignment (abfd, newsect,
72de5009 853 bfd_log2 (hdr->sh_addralign)))
b34976b6 854 return FALSE;
252b5132
RH
855
856 flags = SEC_NO_FLAGS;
857 if (hdr->sh_type != SHT_NOBITS)
858 flags |= SEC_HAS_CONTENTS;
dbb410c3 859 if (hdr->sh_type == SHT_GROUP)
b3096250 860 flags |= SEC_GROUP | SEC_EXCLUDE;
252b5132
RH
861 if ((hdr->sh_flags & SHF_ALLOC) != 0)
862 {
863 flags |= SEC_ALLOC;
864 if (hdr->sh_type != SHT_NOBITS)
865 flags |= SEC_LOAD;
866 }
867 if ((hdr->sh_flags & SHF_WRITE) == 0)
868 flags |= SEC_READONLY;
869 if ((hdr->sh_flags & SHF_EXECINSTR) != 0)
870 flags |= SEC_CODE;
871 else if ((flags & SEC_LOAD) != 0)
872 flags |= SEC_DATA;
f5fa8ca2
JJ
873 if ((hdr->sh_flags & SHF_MERGE) != 0)
874 {
875 flags |= SEC_MERGE;
876 newsect->entsize = hdr->sh_entsize;
877 if ((hdr->sh_flags & SHF_STRINGS) != 0)
878 flags |= SEC_STRINGS;
879 }
dbb410c3
AM
880 if (hdr->sh_flags & SHF_GROUP)
881 if (!setup_group (abfd, hdr, newsect))
b34976b6 882 return FALSE;
13ae64f3
JJ
883 if ((hdr->sh_flags & SHF_TLS) != 0)
884 flags |= SEC_THREAD_LOCAL;
18ae9cc1
L
885 if ((hdr->sh_flags & SHF_EXCLUDE) != 0)
886 flags |= SEC_EXCLUDE;
252b5132 887
3d2b39cf 888 if ((flags & SEC_ALLOC) == 0)
7a6cc5fb 889 {
3d2b39cf
L
890 /* The debugging sections appear to be recognized only by name,
891 not any sort of flag. Their SEC_ALLOC bits are cleared. */
3d2b39cf
L
892 if (name [0] == '.')
893 {
f073ced3
AM
894 const char *p;
895 int n;
896 if (name[1] == 'd')
897 p = ".debug", n = 6;
898 else if (name[1] == 'g' && name[2] == 'n')
899 p = ".gnu.linkonce.wi.", n = 17;
900 else if (name[1] == 'g' && name[2] == 'd')
901 p = ".gdb_index", n = 11; /* yes we really do mean 11. */
902 else if (name[1] == 'l')
903 p = ".line", n = 5;
904 else if (name[1] == 's')
905 p = ".stab", n = 5;
906 else if (name[1] == 'z')
907 p = ".zdebug", n = 7;
908 else
909 p = NULL, n = 0;
910 if (p != NULL && strncmp (name, p, n) == 0)
3d2b39cf
L
911 flags |= SEC_DEBUGGING;
912 }
913 }
252b5132
RH
914
915 /* As a GNU extension, if the name begins with .gnu.linkonce, we
916 only link a single copy of the section. This is used to support
917 g++. g++ will emit each template expansion in its own section.
918 The symbols will be defined as weak, so that multiple definitions
919 are permitted. The GNU linker extension is to actually discard
920 all but one of the sections. */
0112cd26 921 if (CONST_STRNEQ (name, ".gnu.linkonce")
b885599b 922 && elf_next_in_group (newsect) == NULL)
252b5132
RH
923 flags |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
924
fa152c49
JW
925 bed = get_elf_backend_data (abfd);
926 if (bed->elf_backend_section_flags)
927 if (! bed->elf_backend_section_flags (&flags, hdr))
b34976b6 928 return FALSE;
fa152c49 929
252b5132 930 if (! bfd_set_section_flags (abfd, newsect, flags))
b34976b6 931 return FALSE;
252b5132 932
718175fa
JK
933 /* We do not parse the PT_NOTE segments as we are interested even in the
934 separate debug info files which may have the segments offsets corrupted.
935 PT_NOTEs from the core files are currently not parsed using BFD. */
936 if (hdr->sh_type == SHT_NOTE)
937 {
baea7ef1 938 bfd_byte *contents;
718175fa 939
baea7ef1 940 if (!bfd_malloc_and_get_section (abfd, newsect, &contents))
718175fa
JK
941 return FALSE;
942
baea7ef1 943 elf_parse_notes (abfd, (char *) contents, hdr->sh_size, -1);
718175fa
JK
944 free (contents);
945 }
946
252b5132
RH
947 if ((flags & SEC_ALLOC) != 0)
948 {
949 Elf_Internal_Phdr *phdr;
6ffd7900
AM
950 unsigned int i, nload;
951
952 /* Some ELF linkers produce binaries with all the program header
953 p_paddr fields zero. If we have such a binary with more than
954 one PT_LOAD header, then leave the section lma equal to vma
955 so that we don't create sections with overlapping lma. */
956 phdr = elf_tdata (abfd)->phdr;
957 for (nload = 0, i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
958 if (phdr->p_paddr != 0)
959 break;
960 else if (phdr->p_type == PT_LOAD && phdr->p_memsz != 0)
961 ++nload;
962 if (i >= elf_elfheader (abfd)->e_phnum && nload > 1)
963 return TRUE;
252b5132 964
252b5132
RH
965 phdr = elf_tdata (abfd)->phdr;
966 for (i = 0; i < elf_elfheader (abfd)->e_phnum; i++, phdr++)
967 {
86b2281f
AM
968 if (((phdr->p_type == PT_LOAD
969 && (hdr->sh_flags & SHF_TLS) == 0)
970 || phdr->p_type == PT_TLS)
9a83a553 971 && ELF_SECTION_IN_SEGMENT (hdr, phdr))
252b5132 972 {
88967714
AM
973 if ((flags & SEC_LOAD) == 0)
974 newsect->lma = (phdr->p_paddr
975 + hdr->sh_addr - phdr->p_vaddr);
976 else
977 /* We used to use the same adjustment for SEC_LOAD
978 sections, but that doesn't work if the segment
979 is packed with code from multiple VMAs.
980 Instead we calculate the section LMA based on
981 the segment LMA. It is assumed that the
982 segment will contain sections with contiguous
983 LMAs, even if the VMAs are not. */
984 newsect->lma = (phdr->p_paddr
985 + hdr->sh_offset - phdr->p_offset);
986
987 /* With contiguous segments, we can't tell from file
988 offsets whether a section with zero size should
989 be placed at the end of one segment or the
990 beginning of the next. Decide based on vaddr. */
991 if (hdr->sh_addr >= phdr->p_vaddr
992 && (hdr->sh_addr + hdr->sh_size
993 <= phdr->p_vaddr + phdr->p_memsz))
994 break;
252b5132
RH
995 }
996 }
997 }
998
4a114e3e
L
999 /* Compress/decompress DWARF debug sections with names: .debug_* and
1000 .zdebug_*, after the section flags is set. */
1001 if ((flags & SEC_DEBUGGING)
1002 && ((name[1] == 'd' && name[6] == '_')
1003 || (name[1] == 'z' && name[7] == '_')))
1004 {
1005 enum { nothing, compress, decompress } action = nothing;
4e011fb5 1006 char *new_name;
4a114e3e
L
1007
1008 if (bfd_is_section_compressed (abfd, newsect))
1009 {
1010 /* Compressed section. Check if we should decompress. */
1011 if ((abfd->flags & BFD_DECOMPRESS))
1012 action = decompress;
1013 }
1014 else
1015 {
1016 /* Normal section. Check if we should compress. */
5a5ed5b0 1017 if ((abfd->flags & BFD_COMPRESS) && newsect->size != 0)
4a114e3e
L
1018 action = compress;
1019 }
1020
4e011fb5 1021 new_name = NULL;
4a114e3e
L
1022 switch (action)
1023 {
1024 case nothing:
1025 break;
1026 case compress:
1027 if (!bfd_init_section_compress_status (abfd, newsect))
1028 {
1029 (*_bfd_error_handler)
bc823199 1030 (_("%B: unable to initialize compress status for section %s"),
4a114e3e
L
1031 abfd, name);
1032 return FALSE;
1033 }
4e011fb5
AM
1034 if (name[1] != 'z')
1035 {
1036 unsigned int len = strlen (name);
1037
1038 new_name = bfd_alloc (abfd, len + 2);
1039 if (new_name == NULL)
1040 return FALSE;
1041 new_name[0] = '.';
1042 new_name[1] = 'z';
1043 memcpy (new_name + 2, name + 1, len);
1044 }
4a114e3e
L
1045 break;
1046 case decompress:
1047 if (!bfd_init_section_decompress_status (abfd, newsect))
1048 {
1049 (*_bfd_error_handler)
bc823199 1050 (_("%B: unable to initialize decompress status for section %s"),
4a114e3e
L
1051 abfd, name);
1052 return FALSE;
1053 }
4e011fb5
AM
1054 if (name[1] == 'z')
1055 {
1056 unsigned int len = strlen (name);
1057
1058 new_name = bfd_alloc (abfd, len);
1059 if (new_name == NULL)
1060 return FALSE;
1061 new_name[0] = '.';
1062 memcpy (new_name + 1, name + 2, len - 1);
1063 }
4a114e3e
L
1064 break;
1065 }
4e011fb5
AM
1066 if (new_name != NULL)
1067 bfd_rename_section (abfd, newsect, new_name);
4a114e3e
L
1068 }
1069
b34976b6 1070 return TRUE;
252b5132
RH
1071}
1072
252b5132
RH
1073const char *const bfd_elf_section_type_names[] = {
1074 "SHT_NULL", "SHT_PROGBITS", "SHT_SYMTAB", "SHT_STRTAB",
1075 "SHT_RELA", "SHT_HASH", "SHT_DYNAMIC", "SHT_NOTE",
1076 "SHT_NOBITS", "SHT_REL", "SHT_SHLIB", "SHT_DYNSYM",
1077};
1078
1049f94e 1079/* ELF relocs are against symbols. If we are producing relocatable
252b5132
RH
1080 output, and the reloc is against an external symbol, and nothing
1081 has given us any additional addend, the resulting reloc will also
1082 be against the same symbol. In such a case, we don't want to
1083 change anything about the way the reloc is handled, since it will
1084 all be done at final link time. Rather than put special case code
1085 into bfd_perform_relocation, all the reloc types use this howto
1086 function. It just short circuits the reloc if producing
1049f94e 1087 relocatable output against an external symbol. */
252b5132 1088
252b5132 1089bfd_reloc_status_type
217aa764
AM
1090bfd_elf_generic_reloc (bfd *abfd ATTRIBUTE_UNUSED,
1091 arelent *reloc_entry,
1092 asymbol *symbol,
1093 void *data ATTRIBUTE_UNUSED,
1094 asection *input_section,
1095 bfd *output_bfd,
1096 char **error_message ATTRIBUTE_UNUSED)
1097{
1098 if (output_bfd != NULL
252b5132
RH
1099 && (symbol->flags & BSF_SECTION_SYM) == 0
1100 && (! reloc_entry->howto->partial_inplace
1101 || reloc_entry->addend == 0))
1102 {
1103 reloc_entry->address += input_section->output_offset;
1104 return bfd_reloc_ok;
1105 }
1106
1107 return bfd_reloc_continue;
1108}
1109\f
0ac4564e
L
1110/* Copy the program header and other data from one object module to
1111 another. */
252b5132 1112
b34976b6 1113bfd_boolean
217aa764 1114_bfd_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2d502050
L
1115{
1116 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1117 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 1118 return TRUE;
2d502050 1119
57b828ef
L
1120 if (!elf_flags_init (obfd))
1121 {
1122 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
1123 elf_flags_init (obfd) = TRUE;
1124 }
2d502050 1125
0ac4564e 1126 elf_gp (obfd) = elf_gp (ibfd);
57b828ef
L
1127
1128 /* Also copy the EI_OSABI field. */
1129 elf_elfheader (obfd)->e_ident[EI_OSABI] =
1130 elf_elfheader (ibfd)->e_ident[EI_OSABI];
104d59d1
JM
1131
1132 /* Copy object attributes. */
1133 _bfd_elf_copy_obj_attributes (ibfd, obfd);
b34976b6 1134 return TRUE;
2d502050
L
1135}
1136
cedc298e
L
1137static const char *
1138get_segment_type (unsigned int p_type)
1139{
1140 const char *pt;
1141 switch (p_type)
1142 {
1143 case PT_NULL: pt = "NULL"; break;
1144 case PT_LOAD: pt = "LOAD"; break;
1145 case PT_DYNAMIC: pt = "DYNAMIC"; break;
1146 case PT_INTERP: pt = "INTERP"; break;
1147 case PT_NOTE: pt = "NOTE"; break;
1148 case PT_SHLIB: pt = "SHLIB"; break;
1149 case PT_PHDR: pt = "PHDR"; break;
1150 case PT_TLS: pt = "TLS"; break;
1151 case PT_GNU_EH_FRAME: pt = "EH_FRAME"; break;
2b05f1b7 1152 case PT_GNU_STACK: pt = "STACK"; break;
cedc298e
L
1153 case PT_GNU_RELRO: pt = "RELRO"; break;
1154 default: pt = NULL; break;
1155 }
1156 return pt;
1157}
1158
f0b79d91
L
1159/* Print out the program headers. */
1160
b34976b6 1161bfd_boolean
217aa764 1162_bfd_elf_print_private_bfd_data (bfd *abfd, void *farg)
252b5132 1163{
a50b1753 1164 FILE *f = (FILE *) farg;
252b5132
RH
1165 Elf_Internal_Phdr *p;
1166 asection *s;
1167 bfd_byte *dynbuf = NULL;
1168
1169 p = elf_tdata (abfd)->phdr;
1170 if (p != NULL)
1171 {
1172 unsigned int i, c;
1173
1174 fprintf (f, _("\nProgram Header:\n"));
1175 c = elf_elfheader (abfd)->e_phnum;
1176 for (i = 0; i < c; i++, p++)
1177 {
cedc298e 1178 const char *pt = get_segment_type (p->p_type);
252b5132
RH
1179 char buf[20];
1180
cedc298e 1181 if (pt == NULL)
252b5132 1182 {
cedc298e
L
1183 sprintf (buf, "0x%lx", p->p_type);
1184 pt = buf;
252b5132 1185 }
dc810e39 1186 fprintf (f, "%8s off 0x", pt);
60b89a18 1187 bfd_fprintf_vma (abfd, f, p->p_offset);
252b5132 1188 fprintf (f, " vaddr 0x");
60b89a18 1189 bfd_fprintf_vma (abfd, f, p->p_vaddr);
252b5132 1190 fprintf (f, " paddr 0x");
60b89a18 1191 bfd_fprintf_vma (abfd, f, p->p_paddr);
252b5132
RH
1192 fprintf (f, " align 2**%u\n", bfd_log2 (p->p_align));
1193 fprintf (f, " filesz 0x");
60b89a18 1194 bfd_fprintf_vma (abfd, f, p->p_filesz);
252b5132 1195 fprintf (f, " memsz 0x");
60b89a18 1196 bfd_fprintf_vma (abfd, f, p->p_memsz);
252b5132
RH
1197 fprintf (f, " flags %c%c%c",
1198 (p->p_flags & PF_R) != 0 ? 'r' : '-',
1199 (p->p_flags & PF_W) != 0 ? 'w' : '-',
1200 (p->p_flags & PF_X) != 0 ? 'x' : '-');
dc810e39
AM
1201 if ((p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X)) != 0)
1202 fprintf (f, " %lx", p->p_flags &~ (unsigned) (PF_R | PF_W | PF_X));
252b5132
RH
1203 fprintf (f, "\n");
1204 }
1205 }
1206
1207 s = bfd_get_section_by_name (abfd, ".dynamic");
1208 if (s != NULL)
1209 {
cb33740c 1210 unsigned int elfsec;
dc810e39 1211 unsigned long shlink;
252b5132
RH
1212 bfd_byte *extdyn, *extdynend;
1213 size_t extdynsize;
217aa764 1214 void (*swap_dyn_in) (bfd *, const void *, Elf_Internal_Dyn *);
252b5132
RH
1215
1216 fprintf (f, _("\nDynamic Section:\n"));
1217
eea6121a 1218 if (!bfd_malloc_and_get_section (abfd, s, &dynbuf))
252b5132
RH
1219 goto error_return;
1220
1221 elfsec = _bfd_elf_section_from_bfd_section (abfd, s);
cb33740c 1222 if (elfsec == SHN_BAD)
252b5132 1223 goto error_return;
dc810e39 1224 shlink = elf_elfsections (abfd)[elfsec]->sh_link;
252b5132
RH
1225
1226 extdynsize = get_elf_backend_data (abfd)->s->sizeof_dyn;
1227 swap_dyn_in = get_elf_backend_data (abfd)->s->swap_dyn_in;
1228
1229 extdyn = dynbuf;
eea6121a 1230 extdynend = extdyn + s->size;
252b5132
RH
1231 for (; extdyn < extdynend; extdyn += extdynsize)
1232 {
1233 Elf_Internal_Dyn dyn;
ad9563d6 1234 const char *name = "";
252b5132 1235 char ab[20];
b34976b6 1236 bfd_boolean stringp;
ad9563d6 1237 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 1238
217aa764 1239 (*swap_dyn_in) (abfd, extdyn, &dyn);
252b5132
RH
1240
1241 if (dyn.d_tag == DT_NULL)
1242 break;
1243
b34976b6 1244 stringp = FALSE;
252b5132
RH
1245 switch (dyn.d_tag)
1246 {
1247 default:
ad9563d6
CM
1248 if (bed->elf_backend_get_target_dtag)
1249 name = (*bed->elf_backend_get_target_dtag) (dyn.d_tag);
1250
1251 if (!strcmp (name, ""))
1252 {
1253 sprintf (ab, "0x%lx", (unsigned long) dyn.d_tag);
1254 name = ab;
1255 }
252b5132
RH
1256 break;
1257
b34976b6 1258 case DT_NEEDED: name = "NEEDED"; stringp = TRUE; break;
252b5132
RH
1259 case DT_PLTRELSZ: name = "PLTRELSZ"; break;
1260 case DT_PLTGOT: name = "PLTGOT"; break;
1261 case DT_HASH: name = "HASH"; break;
1262 case DT_STRTAB: name = "STRTAB"; break;
1263 case DT_SYMTAB: name = "SYMTAB"; break;
1264 case DT_RELA: name = "RELA"; break;
1265 case DT_RELASZ: name = "RELASZ"; break;
1266 case DT_RELAENT: name = "RELAENT"; break;
1267 case DT_STRSZ: name = "STRSZ"; break;
1268 case DT_SYMENT: name = "SYMENT"; break;
1269 case DT_INIT: name = "INIT"; break;
1270 case DT_FINI: name = "FINI"; break;
b34976b6
AM
1271 case DT_SONAME: name = "SONAME"; stringp = TRUE; break;
1272 case DT_RPATH: name = "RPATH"; stringp = TRUE; break;
252b5132
RH
1273 case DT_SYMBOLIC: name = "SYMBOLIC"; break;
1274 case DT_REL: name = "REL"; break;
1275 case DT_RELSZ: name = "RELSZ"; break;
1276 case DT_RELENT: name = "RELENT"; break;
1277 case DT_PLTREL: name = "PLTREL"; break;
1278 case DT_DEBUG: name = "DEBUG"; break;
1279 case DT_TEXTREL: name = "TEXTREL"; break;
1280 case DT_JMPREL: name = "JMPREL"; break;
94558834
L
1281 case DT_BIND_NOW: name = "BIND_NOW"; break;
1282 case DT_INIT_ARRAY: name = "INIT_ARRAY"; break;
1283 case DT_FINI_ARRAY: name = "FINI_ARRAY"; break;
1284 case DT_INIT_ARRAYSZ: name = "INIT_ARRAYSZ"; break;
1285 case DT_FINI_ARRAYSZ: name = "FINI_ARRAYSZ"; break;
b34976b6 1286 case DT_RUNPATH: name = "RUNPATH"; stringp = TRUE; break;
94558834
L
1287 case DT_FLAGS: name = "FLAGS"; break;
1288 case DT_PREINIT_ARRAY: name = "PREINIT_ARRAY"; break;
1289 case DT_PREINIT_ARRAYSZ: name = "PREINIT_ARRAYSZ"; break;
d48188b9 1290 case DT_CHECKSUM: name = "CHECKSUM"; break;
94558834
L
1291 case DT_PLTPADSZ: name = "PLTPADSZ"; break;
1292 case DT_MOVEENT: name = "MOVEENT"; break;
1293 case DT_MOVESZ: name = "MOVESZ"; break;
1294 case DT_FEATURE: name = "FEATURE"; break;
1295 case DT_POSFLAG_1: name = "POSFLAG_1"; break;
1296 case DT_SYMINSZ: name = "SYMINSZ"; break;
1297 case DT_SYMINENT: name = "SYMINENT"; break;
b34976b6
AM
1298 case DT_CONFIG: name = "CONFIG"; stringp = TRUE; break;
1299 case DT_DEPAUDIT: name = "DEPAUDIT"; stringp = TRUE; break;
1300 case DT_AUDIT: name = "AUDIT"; stringp = TRUE; break;
94558834
L
1301 case DT_PLTPAD: name = "PLTPAD"; break;
1302 case DT_MOVETAB: name = "MOVETAB"; break;
1303 case DT_SYMINFO: name = "SYMINFO"; break;
1304 case DT_RELACOUNT: name = "RELACOUNT"; break;
1305 case DT_RELCOUNT: name = "RELCOUNT"; break;
1306 case DT_FLAGS_1: name = "FLAGS_1"; break;
252b5132
RH
1307 case DT_VERSYM: name = "VERSYM"; break;
1308 case DT_VERDEF: name = "VERDEF"; break;
1309 case DT_VERDEFNUM: name = "VERDEFNUM"; break;
1310 case DT_VERNEED: name = "VERNEED"; break;
1311 case DT_VERNEEDNUM: name = "VERNEEDNUM"; break;
b34976b6 1312 case DT_AUXILIARY: name = "AUXILIARY"; stringp = TRUE; break;
94558834 1313 case DT_USED: name = "USED"; break;
b34976b6 1314 case DT_FILTER: name = "FILTER"; stringp = TRUE; break;
fdc90cb4 1315 case DT_GNU_HASH: name = "GNU_HASH"; break;
252b5132
RH
1316 }
1317
ad9563d6 1318 fprintf (f, " %-20s ", name);
252b5132 1319 if (! stringp)
a1f3c56e
AN
1320 {
1321 fprintf (f, "0x");
1322 bfd_fprintf_vma (abfd, f, dyn.d_un.d_val);
1323 }
252b5132
RH
1324 else
1325 {
1326 const char *string;
dc810e39 1327 unsigned int tagv = dyn.d_un.d_val;
252b5132 1328
dc810e39 1329 string = bfd_elf_string_from_elf_section (abfd, shlink, tagv);
252b5132
RH
1330 if (string == NULL)
1331 goto error_return;
1332 fprintf (f, "%s", string);
1333 }
1334 fprintf (f, "\n");
1335 }
1336
1337 free (dynbuf);
1338 dynbuf = NULL;
1339 }
1340
1341 if ((elf_dynverdef (abfd) != 0 && elf_tdata (abfd)->verdef == NULL)
1342 || (elf_dynverref (abfd) != 0 && elf_tdata (abfd)->verref == NULL))
1343 {
fc0e6df6 1344 if (! _bfd_elf_slurp_version_tables (abfd, FALSE))
b34976b6 1345 return FALSE;
252b5132
RH
1346 }
1347
1348 if (elf_dynverdef (abfd) != 0)
1349 {
1350 Elf_Internal_Verdef *t;
1351
1352 fprintf (f, _("\nVersion definitions:\n"));
1353 for (t = elf_tdata (abfd)->verdef; t != NULL; t = t->vd_nextdef)
1354 {
1355 fprintf (f, "%d 0x%2.2x 0x%8.8lx %s\n", t->vd_ndx,
d0fb9a8d
JJ
1356 t->vd_flags, t->vd_hash,
1357 t->vd_nodename ? t->vd_nodename : "<corrupt>");
1358 if (t->vd_auxptr != NULL && t->vd_auxptr->vda_nextptr != NULL)
252b5132
RH
1359 {
1360 Elf_Internal_Verdaux *a;
1361
1362 fprintf (f, "\t");
1363 for (a = t->vd_auxptr->vda_nextptr;
1364 a != NULL;
1365 a = a->vda_nextptr)
d0fb9a8d
JJ
1366 fprintf (f, "%s ",
1367 a->vda_nodename ? a->vda_nodename : "<corrupt>");
252b5132
RH
1368 fprintf (f, "\n");
1369 }
1370 }
1371 }
1372
1373 if (elf_dynverref (abfd) != 0)
1374 {
1375 Elf_Internal_Verneed *t;
1376
1377 fprintf (f, _("\nVersion References:\n"));
1378 for (t = elf_tdata (abfd)->verref; t != NULL; t = t->vn_nextref)
1379 {
1380 Elf_Internal_Vernaux *a;
1381
d0fb9a8d
JJ
1382 fprintf (f, _(" required from %s:\n"),
1383 t->vn_filename ? t->vn_filename : "<corrupt>");
252b5132
RH
1384 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1385 fprintf (f, " 0x%8.8lx 0x%2.2x %2.2d %s\n", a->vna_hash,
d0fb9a8d
JJ
1386 a->vna_flags, a->vna_other,
1387 a->vna_nodename ? a->vna_nodename : "<corrupt>");
252b5132
RH
1388 }
1389 }
1390
b34976b6 1391 return TRUE;
252b5132
RH
1392
1393 error_return:
1394 if (dynbuf != NULL)
1395 free (dynbuf);
b34976b6 1396 return FALSE;
252b5132
RH
1397}
1398
1399/* Display ELF-specific fields of a symbol. */
1400
1401void
217aa764
AM
1402bfd_elf_print_symbol (bfd *abfd,
1403 void *filep,
1404 asymbol *symbol,
1405 bfd_print_symbol_type how)
252b5132 1406{
a50b1753 1407 FILE *file = (FILE *) filep;
252b5132
RH
1408 switch (how)
1409 {
1410 case bfd_print_symbol_name:
1411 fprintf (file, "%s", symbol->name);
1412 break;
1413 case bfd_print_symbol_more:
1414 fprintf (file, "elf ");
60b89a18 1415 bfd_fprintf_vma (abfd, file, symbol->value);
0af1713e 1416 fprintf (file, " %lx", (unsigned long) symbol->flags);
252b5132
RH
1417 break;
1418 case bfd_print_symbol_all:
1419 {
4e8a9624
AM
1420 const char *section_name;
1421 const char *name = NULL;
9c5bfbb7 1422 const struct elf_backend_data *bed;
7a13edea 1423 unsigned char st_other;
dbb410c3 1424 bfd_vma val;
c044fabd 1425
252b5132 1426 section_name = symbol->section ? symbol->section->name : "(*none*)";
587ff49e
RH
1427
1428 bed = get_elf_backend_data (abfd);
1429 if (bed->elf_backend_print_symbol_all)
c044fabd 1430 name = (*bed->elf_backend_print_symbol_all) (abfd, filep, symbol);
587ff49e
RH
1431
1432 if (name == NULL)
1433 {
7ee38065 1434 name = symbol->name;
217aa764 1435 bfd_print_symbol_vandf (abfd, file, symbol);
587ff49e
RH
1436 }
1437
252b5132
RH
1438 fprintf (file, " %s\t", section_name);
1439 /* Print the "other" value for a symbol. For common symbols,
1440 we've already printed the size; now print the alignment.
1441 For other symbols, we have no specified alignment, and
1442 we've printed the address; now print the size. */
dcf6c779 1443 if (symbol->section && bfd_is_com_section (symbol->section))
dbb410c3
AM
1444 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_value;
1445 else
1446 val = ((elf_symbol_type *) symbol)->internal_elf_sym.st_size;
1447 bfd_fprintf_vma (abfd, file, val);
252b5132
RH
1448
1449 /* If we have version information, print it. */
12bd6957
AM
1450 if (elf_dynversym (abfd) != 0
1451 && (elf_dynverdef (abfd) != 0
1452 || elf_dynverref (abfd) != 0))
252b5132
RH
1453 {
1454 unsigned int vernum;
1455 const char *version_string;
1456
1457 vernum = ((elf_symbol_type *) symbol)->version & VERSYM_VERSION;
1458
1459 if (vernum == 0)
1460 version_string = "";
1461 else if (vernum == 1)
1462 version_string = "Base";
1463 else if (vernum <= elf_tdata (abfd)->cverdefs)
1464 version_string =
1465 elf_tdata (abfd)->verdef[vernum - 1].vd_nodename;
1466 else
1467 {
1468 Elf_Internal_Verneed *t;
1469
1470 version_string = "";
1471 for (t = elf_tdata (abfd)->verref;
1472 t != NULL;
1473 t = t->vn_nextref)
1474 {
1475 Elf_Internal_Vernaux *a;
1476
1477 for (a = t->vn_auxptr; a != NULL; a = a->vna_nextptr)
1478 {
1479 if (a->vna_other == vernum)
1480 {
1481 version_string = a->vna_nodename;
1482 break;
1483 }
1484 }
1485 }
1486 }
1487
1488 if ((((elf_symbol_type *) symbol)->version & VERSYM_HIDDEN) == 0)
1489 fprintf (file, " %-11s", version_string);
1490 else
1491 {
1492 int i;
1493
1494 fprintf (file, " (%s)", version_string);
1495 for (i = 10 - strlen (version_string); i > 0; --i)
1496 putc (' ', file);
1497 }
1498 }
1499
1500 /* If the st_other field is not zero, print it. */
7a13edea 1501 st_other = ((elf_symbol_type *) symbol)->internal_elf_sym.st_other;
c044fabd 1502
7a13edea
NC
1503 switch (st_other)
1504 {
1505 case 0: break;
1506 case STV_INTERNAL: fprintf (file, " .internal"); break;
1507 case STV_HIDDEN: fprintf (file, " .hidden"); break;
1508 case STV_PROTECTED: fprintf (file, " .protected"); break;
1509 default:
1510 /* Some other non-defined flags are also present, so print
1511 everything hex. */
1512 fprintf (file, " 0x%02x", (unsigned int) st_other);
1513 }
252b5132 1514
587ff49e 1515 fprintf (file, " %s", name);
252b5132
RH
1516 }
1517 break;
1518 }
1519}
252b5132 1520
252b5132
RH
1521/* Allocate an ELF string table--force the first byte to be zero. */
1522
1523struct bfd_strtab_hash *
217aa764 1524_bfd_elf_stringtab_init (void)
252b5132
RH
1525{
1526 struct bfd_strtab_hash *ret;
1527
1528 ret = _bfd_stringtab_init ();
1529 if (ret != NULL)
1530 {
1531 bfd_size_type loc;
1532
b34976b6 1533 loc = _bfd_stringtab_add (ret, "", TRUE, FALSE);
252b5132
RH
1534 BFD_ASSERT (loc == 0 || loc == (bfd_size_type) -1);
1535 if (loc == (bfd_size_type) -1)
1536 {
1537 _bfd_stringtab_free (ret);
1538 ret = NULL;
1539 }
1540 }
1541 return ret;
1542}
1543\f
1544/* ELF .o/exec file reading */
1545
c044fabd 1546/* Create a new bfd section from an ELF section header. */
252b5132 1547
b34976b6 1548bfd_boolean
217aa764 1549bfd_section_from_shdr (bfd *abfd, unsigned int shindex)
252b5132 1550{
4fbb74a6
AM
1551 Elf_Internal_Shdr *hdr;
1552 Elf_Internal_Ehdr *ehdr;
1553 const struct elf_backend_data *bed;
90937f86 1554 const char *name;
252b5132 1555
4fbb74a6
AM
1556 if (shindex >= elf_numsections (abfd))
1557 return FALSE;
1558
1559 hdr = elf_elfsections (abfd)[shindex];
1560 ehdr = elf_elfheader (abfd);
1561 name = bfd_elf_string_from_elf_section (abfd, ehdr->e_shstrndx,
1b3a8575 1562 hdr->sh_name);
933d961a
JJ
1563 if (name == NULL)
1564 return FALSE;
252b5132 1565
4fbb74a6 1566 bed = get_elf_backend_data (abfd);
252b5132
RH
1567 switch (hdr->sh_type)
1568 {
1569 case SHT_NULL:
1570 /* Inactive section. Throw it away. */
b34976b6 1571 return TRUE;
252b5132
RH
1572
1573 case SHT_PROGBITS: /* Normal section with contents. */
252b5132
RH
1574 case SHT_NOBITS: /* .bss section. */
1575 case SHT_HASH: /* .hash section. */
1576 case SHT_NOTE: /* .note section. */
25e27870
L
1577 case SHT_INIT_ARRAY: /* .init_array section. */
1578 case SHT_FINI_ARRAY: /* .fini_array section. */
1579 case SHT_PREINIT_ARRAY: /* .preinit_array section. */
7f1204bb 1580 case SHT_GNU_LIBLIST: /* .gnu.liblist section. */
fdc90cb4 1581 case SHT_GNU_HASH: /* .gnu.hash section. */
6dc132d9 1582 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
252b5132 1583
797fc050 1584 case SHT_DYNAMIC: /* Dynamic linking information. */
6dc132d9 1585 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
b34976b6 1586 return FALSE;
cfcac11d
NC
1587 if (hdr->sh_link > elf_numsections (abfd))
1588 {
caa83f8b 1589 /* PR 10478: Accept Solaris binaries with a sh_link
cfcac11d
NC
1590 field set to SHN_BEFORE or SHN_AFTER. */
1591 switch (bfd_get_arch (abfd))
1592 {
caa83f8b 1593 case bfd_arch_i386:
cfcac11d
NC
1594 case bfd_arch_sparc:
1595 if (hdr->sh_link == (SHN_LORESERVE & 0xffff) /* SHN_BEFORE */
1596 || hdr->sh_link == ((SHN_LORESERVE + 1) & 0xffff) /* SHN_AFTER */)
1597 break;
1598 /* Otherwise fall through. */
1599 default:
1600 return FALSE;
1601 }
1602 }
1603 else if (elf_elfsections (abfd)[hdr->sh_link] == NULL)
8e0ed13f 1604 return FALSE;
cfcac11d 1605 else if (elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_STRTAB)
797fc050
AM
1606 {
1607 Elf_Internal_Shdr *dynsymhdr;
1608
1609 /* The shared libraries distributed with hpux11 have a bogus
1610 sh_link field for the ".dynamic" section. Find the
1611 string table for the ".dynsym" section instead. */
1612 if (elf_dynsymtab (abfd) != 0)
1613 {
1614 dynsymhdr = elf_elfsections (abfd)[elf_dynsymtab (abfd)];
1615 hdr->sh_link = dynsymhdr->sh_link;
1616 }
1617 else
1618 {
1619 unsigned int i, num_sec;
1620
1621 num_sec = elf_numsections (abfd);
1622 for (i = 1; i < num_sec; i++)
1623 {
1624 dynsymhdr = elf_elfsections (abfd)[i];
1625 if (dynsymhdr->sh_type == SHT_DYNSYM)
1626 {
1627 hdr->sh_link = dynsymhdr->sh_link;
1628 break;
1629 }
1630 }
1631 }
1632 }
1633 break;
1634
252b5132
RH
1635 case SHT_SYMTAB: /* A symbol table */
1636 if (elf_onesymtab (abfd) == shindex)
b34976b6 1637 return TRUE;
252b5132 1638
a50b2160
JJ
1639 if (hdr->sh_entsize != bed->s->sizeof_sym)
1640 return FALSE;
3337c1e5 1641 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
eee3b786
AM
1642 {
1643 if (hdr->sh_size != 0)
1644 return FALSE;
1645 /* Some assemblers erroneously set sh_info to one with a
1646 zero sh_size. ld sees this as a global symbol count
1647 of (unsigned) -1. Fix it here. */
1648 hdr->sh_info = 0;
1649 return TRUE;
1650 }
252b5132
RH
1651 BFD_ASSERT (elf_onesymtab (abfd) == 0);
1652 elf_onesymtab (abfd) = shindex;
1653 elf_tdata (abfd)->symtab_hdr = *hdr;
1654 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->symtab_hdr;
1655 abfd->flags |= HAS_SYMS;
1656
1657 /* Sometimes a shared object will map in the symbol table. If
08a40648
AM
1658 SHF_ALLOC is set, and this is a shared object, then we also
1659 treat this section as a BFD section. We can not base the
1660 decision purely on SHF_ALLOC, because that flag is sometimes
1661 set in a relocatable object file, which would confuse the
1662 linker. */
252b5132
RH
1663 if ((hdr->sh_flags & SHF_ALLOC) != 0
1664 && (abfd->flags & DYNAMIC) != 0
6dc132d9
L
1665 && ! _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1666 shindex))
b34976b6 1667 return FALSE;
252b5132 1668
1b3a8575
AM
1669 /* Go looking for SHT_SYMTAB_SHNDX too, since if there is one we
1670 can't read symbols without that section loaded as well. It
1671 is most likely specified by the next section header. */
1672 if (elf_elfsections (abfd)[elf_symtab_shndx (abfd)]->sh_link != shindex)
1673 {
1674 unsigned int i, num_sec;
1675
1676 num_sec = elf_numsections (abfd);
1677 for (i = shindex + 1; i < num_sec; i++)
1678 {
1679 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1680 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1681 && hdr2->sh_link == shindex)
1682 break;
1683 }
1684 if (i == num_sec)
1685 for (i = 1; i < shindex; i++)
1686 {
1687 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1688 if (hdr2->sh_type == SHT_SYMTAB_SHNDX
1689 && hdr2->sh_link == shindex)
1690 break;
1691 }
1692 if (i != shindex)
1693 return bfd_section_from_shdr (abfd, i);
1694 }
b34976b6 1695 return TRUE;
252b5132
RH
1696
1697 case SHT_DYNSYM: /* A dynamic symbol table */
1698 if (elf_dynsymtab (abfd) == shindex)
b34976b6 1699 return TRUE;
252b5132 1700
a50b2160
JJ
1701 if (hdr->sh_entsize != bed->s->sizeof_sym)
1702 return FALSE;
eee3b786
AM
1703 if (hdr->sh_info * hdr->sh_entsize > hdr->sh_size)
1704 {
1705 if (hdr->sh_size != 0)
1706 return FALSE;
1707 /* Some linkers erroneously set sh_info to one with a
1708 zero sh_size. ld sees this as a global symbol count
1709 of (unsigned) -1. Fix it here. */
1710 hdr->sh_info = 0;
1711 return TRUE;
1712 }
252b5132
RH
1713 BFD_ASSERT (elf_dynsymtab (abfd) == 0);
1714 elf_dynsymtab (abfd) = shindex;
1715 elf_tdata (abfd)->dynsymtab_hdr = *hdr;
1716 elf_elfsections (abfd)[shindex] = hdr = &elf_tdata (abfd)->dynsymtab_hdr;
1717 abfd->flags |= HAS_SYMS;
1718
1719 /* Besides being a symbol table, we also treat this as a regular
1720 section, so that objcopy can handle it. */
6dc132d9 1721 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
252b5132 1722
9ad5cbcf
AM
1723 case SHT_SYMTAB_SHNDX: /* Symbol section indices when >64k sections */
1724 if (elf_symtab_shndx (abfd) == shindex)
b34976b6 1725 return TRUE;
9ad5cbcf 1726
1b3a8575 1727 BFD_ASSERT (elf_symtab_shndx (abfd) == 0);
9ad5cbcf
AM
1728 elf_symtab_shndx (abfd) = shindex;
1729 elf_tdata (abfd)->symtab_shndx_hdr = *hdr;
1730 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->symtab_shndx_hdr;
b34976b6 1731 return TRUE;
9ad5cbcf 1732
252b5132
RH
1733 case SHT_STRTAB: /* A string table */
1734 if (hdr->bfd_section != NULL)
b34976b6 1735 return TRUE;
252b5132
RH
1736 if (ehdr->e_shstrndx == shindex)
1737 {
1738 elf_tdata (abfd)->shstrtab_hdr = *hdr;
1739 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->shstrtab_hdr;
b34976b6 1740 return TRUE;
252b5132 1741 }
1b3a8575
AM
1742 if (elf_elfsections (abfd)[elf_onesymtab (abfd)]->sh_link == shindex)
1743 {
1744 symtab_strtab:
1745 elf_tdata (abfd)->strtab_hdr = *hdr;
1746 elf_elfsections (abfd)[shindex] = &elf_tdata (abfd)->strtab_hdr;
1747 return TRUE;
1748 }
1749 if (elf_elfsections (abfd)[elf_dynsymtab (abfd)]->sh_link == shindex)
1750 {
1751 dynsymtab_strtab:
1752 elf_tdata (abfd)->dynstrtab_hdr = *hdr;
1753 hdr = &elf_tdata (abfd)->dynstrtab_hdr;
1754 elf_elfsections (abfd)[shindex] = hdr;
1755 /* We also treat this as a regular section, so that objcopy
1756 can handle it. */
6dc132d9
L
1757 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1758 shindex);
1b3a8575 1759 }
252b5132 1760
1b3a8575
AM
1761 /* If the string table isn't one of the above, then treat it as a
1762 regular section. We need to scan all the headers to be sure,
1763 just in case this strtab section appeared before the above. */
1764 if (elf_onesymtab (abfd) == 0 || elf_dynsymtab (abfd) == 0)
1765 {
1766 unsigned int i, num_sec;
252b5132 1767
1b3a8575
AM
1768 num_sec = elf_numsections (abfd);
1769 for (i = 1; i < num_sec; i++)
1770 {
1771 Elf_Internal_Shdr *hdr2 = elf_elfsections (abfd)[i];
1772 if (hdr2->sh_link == shindex)
1773 {
933d961a
JJ
1774 /* Prevent endless recursion on broken objects. */
1775 if (i == shindex)
1776 return FALSE;
1b3a8575
AM
1777 if (! bfd_section_from_shdr (abfd, i))
1778 return FALSE;
1779 if (elf_onesymtab (abfd) == i)
1780 goto symtab_strtab;
1781 if (elf_dynsymtab (abfd) == i)
1782 goto dynsymtab_strtab;
1783 }
1784 }
1785 }
6dc132d9 1786 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
252b5132
RH
1787
1788 case SHT_REL:
1789 case SHT_RELA:
1790 /* *These* do a lot of work -- but build no sections! */
1791 {
1792 asection *target_sect;
d4730f92 1793 Elf_Internal_Shdr *hdr2, **p_hdr;
9ad5cbcf 1794 unsigned int num_sec = elf_numsections (abfd);
d4730f92
BS
1795 struct bfd_elf_section_data *esdt;
1796 bfd_size_type amt;
252b5132 1797
aa2ca951
JJ
1798 if (hdr->sh_entsize
1799 != (bfd_size_type) (hdr->sh_type == SHT_REL
a50b2160
JJ
1800 ? bed->s->sizeof_rel : bed->s->sizeof_rela))
1801 return FALSE;
1802
03ae5f59 1803 /* Check for a bogus link to avoid crashing. */
4fbb74a6 1804 if (hdr->sh_link >= num_sec)
03ae5f59
ILT
1805 {
1806 ((*_bfd_error_handler)
d003868e
AM
1807 (_("%B: invalid link %lu for reloc section %s (index %u)"),
1808 abfd, hdr->sh_link, name, shindex));
6dc132d9
L
1809 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1810 shindex);
03ae5f59
ILT
1811 }
1812
252b5132
RH
1813 /* For some incomprehensible reason Oracle distributes
1814 libraries for Solaris in which some of the objects have
1815 bogus sh_link fields. It would be nice if we could just
1816 reject them, but, unfortunately, some people need to use
1817 them. We scan through the section headers; if we find only
1818 one suitable symbol table, we clobber the sh_link to point
83b89087
L
1819 to it. I hope this doesn't break anything.
1820
1821 Don't do it on executable nor shared library. */
1822 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0
1823 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_SYMTAB
252b5132
RH
1824 && elf_elfsections (abfd)[hdr->sh_link]->sh_type != SHT_DYNSYM)
1825 {
9ad5cbcf 1826 unsigned int scan;
252b5132
RH
1827 int found;
1828
1829 found = 0;
9ad5cbcf 1830 for (scan = 1; scan < num_sec; scan++)
252b5132
RH
1831 {
1832 if (elf_elfsections (abfd)[scan]->sh_type == SHT_SYMTAB
1833 || elf_elfsections (abfd)[scan]->sh_type == SHT_DYNSYM)
1834 {
1835 if (found != 0)
1836 {
1837 found = 0;
1838 break;
1839 }
1840 found = scan;
1841 }
1842 }
1843 if (found != 0)
1844 hdr->sh_link = found;
1845 }
1846
1847 /* Get the symbol table. */
1b3a8575
AM
1848 if ((elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_SYMTAB
1849 || elf_elfsections (abfd)[hdr->sh_link]->sh_type == SHT_DYNSYM)
252b5132 1850 && ! bfd_section_from_shdr (abfd, hdr->sh_link))
b34976b6 1851 return FALSE;
252b5132
RH
1852
1853 /* If this reloc section does not use the main symbol table we
1854 don't treat it as a reloc section. BFD can't adequately
1855 represent such a section, so at least for now, we don't
c044fabd 1856 try. We just present it as a normal section. We also
60bcf0fa 1857 can't use it as a reloc section if it points to the null
83b89087
L
1858 section, an invalid section, another reloc section, or its
1859 sh_link points to the null section. */
185ef66d 1860 if (hdr->sh_link != elf_onesymtab (abfd)
83b89087 1861 || hdr->sh_link == SHN_UNDEF
185ef66d 1862 || hdr->sh_info == SHN_UNDEF
185ef66d
AM
1863 || hdr->sh_info >= num_sec
1864 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_REL
1865 || elf_elfsections (abfd)[hdr->sh_info]->sh_type == SHT_RELA)
6dc132d9
L
1866 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1867 shindex);
252b5132
RH
1868
1869 if (! bfd_section_from_shdr (abfd, hdr->sh_info))
b34976b6 1870 return FALSE;
252b5132
RH
1871 target_sect = bfd_section_from_elf_index (abfd, hdr->sh_info);
1872 if (target_sect == NULL)
b34976b6 1873 return FALSE;
252b5132 1874
d4730f92
BS
1875 esdt = elf_section_data (target_sect);
1876 if (hdr->sh_type == SHT_RELA)
1877 p_hdr = &esdt->rela.hdr;
252b5132 1878 else
d4730f92
BS
1879 p_hdr = &esdt->rel.hdr;
1880
1881 BFD_ASSERT (*p_hdr == NULL);
1882 amt = sizeof (*hdr2);
1883 hdr2 = (Elf_Internal_Shdr *) bfd_alloc (abfd, amt);
1884 if (hdr2 == NULL)
1885 return FALSE;
252b5132 1886 *hdr2 = *hdr;
d4730f92 1887 *p_hdr = hdr2;
252b5132 1888 elf_elfsections (abfd)[shindex] = hdr2;
d9bc7a44 1889 target_sect->reloc_count += NUM_SHDR_ENTRIES (hdr);
252b5132
RH
1890 target_sect->flags |= SEC_RELOC;
1891 target_sect->relocation = NULL;
1892 target_sect->rel_filepos = hdr->sh_offset;
bf572ba0
MM
1893 /* In the section to which the relocations apply, mark whether
1894 its relocations are of the REL or RELA variety. */
72730e0c 1895 if (hdr->sh_size != 0)
d4730f92
BS
1896 {
1897 if (hdr->sh_type == SHT_RELA)
1898 target_sect->use_rela_p = 1;
1899 }
252b5132 1900 abfd->flags |= HAS_RELOC;
b34976b6 1901 return TRUE;
252b5132 1902 }
252b5132
RH
1903
1904 case SHT_GNU_verdef:
1905 elf_dynverdef (abfd) = shindex;
1906 elf_tdata (abfd)->dynverdef_hdr = *hdr;
6dc132d9 1907 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
252b5132
RH
1908
1909 case SHT_GNU_versym:
a50b2160
JJ
1910 if (hdr->sh_entsize != sizeof (Elf_External_Versym))
1911 return FALSE;
252b5132
RH
1912 elf_dynversym (abfd) = shindex;
1913 elf_tdata (abfd)->dynversym_hdr = *hdr;
6dc132d9 1914 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
252b5132
RH
1915
1916 case SHT_GNU_verneed:
1917 elf_dynverref (abfd) = shindex;
1918 elf_tdata (abfd)->dynverref_hdr = *hdr;
6dc132d9 1919 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
252b5132
RH
1920
1921 case SHT_SHLIB:
b34976b6 1922 return TRUE;
252b5132 1923
dbb410c3 1924 case SHT_GROUP:
44534af3 1925 if (! IS_VALID_GROUP_SECTION_HEADER (hdr, GRP_ENTRY_SIZE))
a50b2160 1926 return FALSE;
6dc132d9 1927 if (!_bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
b34976b6 1928 return FALSE;
dbb410c3
AM
1929 if (hdr->contents != NULL)
1930 {
1931 Elf_Internal_Group *idx = (Elf_Internal_Group *) hdr->contents;
1783205a 1932 unsigned int n_elt = hdr->sh_size / GRP_ENTRY_SIZE;
dbb410c3
AM
1933 asection *s;
1934
b885599b
AM
1935 if (idx->flags & GRP_COMDAT)
1936 hdr->bfd_section->flags
1937 |= SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD;
1938
45c5e9ed
L
1939 /* We try to keep the same section order as it comes in. */
1940 idx += n_elt;
dbb410c3 1941 while (--n_elt != 0)
1783205a
NC
1942 {
1943 --idx;
1944
1945 if (idx->shdr != NULL
1946 && (s = idx->shdr->bfd_section) != NULL
1947 && elf_next_in_group (s) != NULL)
1948 {
1949 elf_next_in_group (hdr->bfd_section) = s;
1950 break;
1951 }
1952 }
dbb410c3
AM
1953 }
1954 break;
1955
252b5132 1956 default:
104d59d1
JM
1957 /* Possibly an attributes section. */
1958 if (hdr->sh_type == SHT_GNU_ATTRIBUTES
1959 || hdr->sh_type == bed->obj_attrs_section_type)
1960 {
1961 if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
1962 return FALSE;
1963 _bfd_elf_parse_attributes (abfd, hdr);
1964 return TRUE;
1965 }
1966
252b5132 1967 /* Check for any processor-specific section types. */
3eb70a79
L
1968 if (bed->elf_backend_section_from_shdr (abfd, hdr, name, shindex))
1969 return TRUE;
1970
1971 if (hdr->sh_type >= SHT_LOUSER && hdr->sh_type <= SHT_HIUSER)
1972 {
1973 if ((hdr->sh_flags & SHF_ALLOC) != 0)
1974 /* FIXME: How to properly handle allocated section reserved
1975 for applications? */
1976 (*_bfd_error_handler)
1977 (_("%B: don't know how to handle allocated, application "
1978 "specific section `%s' [0x%8x]"),
1979 abfd, name, hdr->sh_type);
1980 else
1981 /* Allow sections reserved for applications. */
1982 return _bfd_elf_make_section_from_shdr (abfd, hdr, name,
1983 shindex);
1984 }
1985 else if (hdr->sh_type >= SHT_LOPROC
1986 && hdr->sh_type <= SHT_HIPROC)
1987 /* FIXME: We should handle this section. */
1988 (*_bfd_error_handler)
1989 (_("%B: don't know how to handle processor specific section "
1990 "`%s' [0x%8x]"),
1991 abfd, name, hdr->sh_type);
1992 else if (hdr->sh_type >= SHT_LOOS && hdr->sh_type <= SHT_HIOS)
ff15b240
NC
1993 {
1994 /* Unrecognised OS-specific sections. */
1995 if ((hdr->sh_flags & SHF_OS_NONCONFORMING) != 0)
1996 /* SHF_OS_NONCONFORMING indicates that special knowledge is
08a40648 1997 required to correctly process the section and the file should
ff15b240
NC
1998 be rejected with an error message. */
1999 (*_bfd_error_handler)
2000 (_("%B: don't know how to handle OS specific section "
2001 "`%s' [0x%8x]"),
2002 abfd, name, hdr->sh_type);
2003 else
2004 /* Otherwise it should be processed. */
2005 return _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex);
2006 }
3eb70a79
L
2007 else
2008 /* FIXME: We should handle this section. */
2009 (*_bfd_error_handler)
2010 (_("%B: don't know how to handle section `%s' [0x%8x]"),
2011 abfd, name, hdr->sh_type);
2012
2013 return FALSE;
252b5132
RH
2014 }
2015
b34976b6 2016 return TRUE;
252b5132
RH
2017}
2018
87d72d41 2019/* Return the local symbol specified by ABFD, R_SYMNDX. */
ec338859 2020
87d72d41
AM
2021Elf_Internal_Sym *
2022bfd_sym_from_r_symndx (struct sym_cache *cache,
2023 bfd *abfd,
2024 unsigned long r_symndx)
ec338859 2025{
ec338859
AM
2026 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
2027
a5d1b3b5
AM
2028 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
2029 {
2030 Elf_Internal_Shdr *symtab_hdr;
2031 unsigned char esym[sizeof (Elf64_External_Sym)];
2032 Elf_External_Sym_Shndx eshndx;
ec338859 2033
a5d1b3b5
AM
2034 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2035 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
87d72d41 2036 &cache->sym[ent], esym, &eshndx) == NULL)
a5d1b3b5 2037 return NULL;
9ad5cbcf 2038
a5d1b3b5
AM
2039 if (cache->abfd != abfd)
2040 {
2041 memset (cache->indx, -1, sizeof (cache->indx));
2042 cache->abfd = abfd;
2043 }
2044 cache->indx[ent] = r_symndx;
ec338859 2045 }
a5d1b3b5 2046
87d72d41 2047 return &cache->sym[ent];
ec338859
AM
2048}
2049
252b5132
RH
2050/* Given an ELF section number, retrieve the corresponding BFD
2051 section. */
2052
2053asection *
91d6fa6a 2054bfd_section_from_elf_index (bfd *abfd, unsigned int sec_index)
252b5132 2055{
91d6fa6a 2056 if (sec_index >= elf_numsections (abfd))
252b5132 2057 return NULL;
91d6fa6a 2058 return elf_elfsections (abfd)[sec_index]->bfd_section;
252b5132
RH
2059}
2060
b35d266b 2061static const struct bfd_elf_special_section special_sections_b[] =
2f89ff8d 2062{
0112cd26
NC
2063 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2064 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2065};
2066
b35d266b 2067static const struct bfd_elf_special_section special_sections_c[] =
7f4d3958 2068{
0112cd26
NC
2069 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
2070 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2071};
2072
b35d266b 2073static const struct bfd_elf_special_section special_sections_d[] =
7f4d3958 2074{
0112cd26
NC
2075 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2076 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
a9a72a65
DE
2077 /* There are more DWARF sections than these, but they needn't be added here
2078 unless you have to cope with broken compilers that don't emit section
2079 attributes or you want to help the user writing assembler. */
0112cd26
NC
2080 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
2081 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
2082 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
2083 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
2084 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
2085 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
2086 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
2087 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
2088 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2089};
2090
b35d266b 2091static const struct bfd_elf_special_section special_sections_f[] =
7f4d3958 2092{
0112cd26
NC
2093 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2094 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2095 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2096};
2097
b35d266b 2098static const struct bfd_elf_special_section special_sections_g[] =
7f4d3958 2099{
0112cd26 2100 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
68efed41 2101 { STRING_COMMA_LEN (".gnu.lto_"), -1, SHT_PROGBITS, SHF_EXCLUDE },
0112cd26
NC
2102 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2103 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2104 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2105 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2106 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2107 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2108 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2109 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2110};
2111
b35d266b 2112static const struct bfd_elf_special_section special_sections_h[] =
7f4d3958 2113{
0112cd26
NC
2114 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2115 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2116};
2117
b35d266b 2118static const struct bfd_elf_special_section special_sections_i[] =
7f4d3958 2119{
0112cd26
NC
2120 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2121 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2122 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2123 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2124};
2125
b35d266b 2126static const struct bfd_elf_special_section special_sections_l[] =
7f4d3958 2127{
0112cd26
NC
2128 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2129 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2130};
2131
b35d266b 2132static const struct bfd_elf_special_section special_sections_n[] =
7f4d3958 2133{
0112cd26
NC
2134 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2135 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2136 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2137};
2138
b35d266b 2139static const struct bfd_elf_special_section special_sections_p[] =
7f4d3958 2140{
0112cd26
NC
2141 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2142 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2143 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2144};
2145
b35d266b 2146static const struct bfd_elf_special_section special_sections_r[] =
7f4d3958 2147{
0112cd26
NC
2148 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2149 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2150 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2151 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2152 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2153};
2154
b35d266b 2155static const struct bfd_elf_special_section special_sections_s[] =
7f4d3958 2156{
0112cd26
NC
2157 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2158 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2159 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
60ff4dc4
HPN
2160 /* See struct bfd_elf_special_section declaration for the semantics of
2161 this special case where .prefix_length != strlen (.prefix). */
2162 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
0112cd26 2163 { NULL, 0, 0, 0, 0 }
2f89ff8d
L
2164};
2165
b35d266b 2166static const struct bfd_elf_special_section special_sections_t[] =
7f4d3958 2167{
0112cd26
NC
2168 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2169 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2170 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2171 { NULL, 0, 0, 0, 0 }
7f4d3958
L
2172};
2173
1b315056
CS
2174static const struct bfd_elf_special_section special_sections_z[] =
2175{
2176 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2177 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2178 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2179 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2180 { NULL, 0, 0, 0, 0 }
2181};
2182
e4c93b56 2183static const struct bfd_elf_special_section * const special_sections[] =
7f4d3958 2184{
7f4d3958 2185 special_sections_b, /* 'b' */
98ece1b3 2186 special_sections_c, /* 'c' */
7f4d3958
L
2187 special_sections_d, /* 'd' */
2188 NULL, /* 'e' */
2189 special_sections_f, /* 'f' */
2190 special_sections_g, /* 'g' */
2191 special_sections_h, /* 'h' */
2192 special_sections_i, /* 'i' */
2193 NULL, /* 'j' */
2194 NULL, /* 'k' */
2195 special_sections_l, /* 'l' */
2196 NULL, /* 'm' */
2197 special_sections_n, /* 'n' */
2198 NULL, /* 'o' */
2199 special_sections_p, /* 'p' */
2200 NULL, /* 'q' */
2201 special_sections_r, /* 'r' */
2202 special_sections_s, /* 's' */
2203 special_sections_t, /* 't' */
1b315056
CS
2204 NULL, /* 'u' */
2205 NULL, /* 'v' */
2206 NULL, /* 'w' */
2207 NULL, /* 'x' */
2208 NULL, /* 'y' */
2209 special_sections_z /* 'z' */
7f4d3958
L
2210};
2211
551b43fd
AM
2212const struct bfd_elf_special_section *
2213_bfd_elf_get_special_section (const char *name,
2214 const struct bfd_elf_special_section *spec,
2215 unsigned int rela)
2f89ff8d
L
2216{
2217 int i;
7f4d3958 2218 int len;
7f4d3958 2219
551b43fd 2220 len = strlen (name);
7f4d3958 2221
551b43fd 2222 for (i = 0; spec[i].prefix != NULL; i++)
7dcb9820
AM
2223 {
2224 int suffix_len;
551b43fd 2225 int prefix_len = spec[i].prefix_length;
7dcb9820
AM
2226
2227 if (len < prefix_len)
2228 continue;
551b43fd 2229 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
7dcb9820
AM
2230 continue;
2231
551b43fd 2232 suffix_len = spec[i].suffix_length;
7dcb9820
AM
2233 if (suffix_len <= 0)
2234 {
2235 if (name[prefix_len] != 0)
2236 {
2237 if (suffix_len == 0)
2238 continue;
2239 if (name[prefix_len] != '.'
2240 && (suffix_len == -2
551b43fd 2241 || (rela && spec[i].type == SHT_REL)))
7dcb9820
AM
2242 continue;
2243 }
2244 }
2245 else
2246 {
2247 if (len < prefix_len + suffix_len)
2248 continue;
2249 if (memcmp (name + len - suffix_len,
551b43fd 2250 spec[i].prefix + prefix_len,
7dcb9820
AM
2251 suffix_len) != 0)
2252 continue;
2253 }
551b43fd 2254 return &spec[i];
7dcb9820 2255 }
2f89ff8d
L
2256
2257 return NULL;
2258}
2259
7dcb9820 2260const struct bfd_elf_special_section *
29ef7005 2261_bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2f89ff8d 2262{
551b43fd
AM
2263 int i;
2264 const struct bfd_elf_special_section *spec;
29ef7005 2265 const struct elf_backend_data *bed;
2f89ff8d
L
2266
2267 /* See if this is one of the special sections. */
551b43fd
AM
2268 if (sec->name == NULL)
2269 return NULL;
2f89ff8d 2270
29ef7005
L
2271 bed = get_elf_backend_data (abfd);
2272 spec = bed->special_sections;
2273 if (spec)
2274 {
2275 spec = _bfd_elf_get_special_section (sec->name,
2276 bed->special_sections,
2277 sec->use_rela_p);
2278 if (spec != NULL)
2279 return spec;
2280 }
2281
551b43fd
AM
2282 if (sec->name[0] != '.')
2283 return NULL;
2f89ff8d 2284
551b43fd 2285 i = sec->name[1] - 'b';
1b315056 2286 if (i < 0 || i > 'z' - 'b')
551b43fd
AM
2287 return NULL;
2288
2289 spec = special_sections[i];
2f89ff8d 2290
551b43fd
AM
2291 if (spec == NULL)
2292 return NULL;
2293
2294 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2f89ff8d
L
2295}
2296
b34976b6 2297bfd_boolean
217aa764 2298_bfd_elf_new_section_hook (bfd *abfd, asection *sec)
252b5132
RH
2299{
2300 struct bfd_elf_section_data *sdata;
551b43fd 2301 const struct elf_backend_data *bed;
7dcb9820 2302 const struct bfd_elf_special_section *ssect;
252b5132 2303
f0abc2a1
AM
2304 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2305 if (sdata == NULL)
2306 {
a50b1753
NC
2307 sdata = (struct bfd_elf_section_data *) bfd_zalloc (abfd,
2308 sizeof (*sdata));
f0abc2a1
AM
2309 if (sdata == NULL)
2310 return FALSE;
217aa764 2311 sec->used_by_bfd = sdata;
f0abc2a1 2312 }
bf572ba0 2313
551b43fd
AM
2314 /* Indicate whether or not this section should use RELA relocations. */
2315 bed = get_elf_backend_data (abfd);
2316 sec->use_rela_p = bed->default_use_rela_p;
2317
e843e0f8
L
2318 /* When we read a file, we don't need to set ELF section type and
2319 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2320 anyway. We will set ELF section type and flags for all linker
2321 created sections. If user specifies BFD section flags, we will
2322 set ELF section type and flags based on BFD section flags in
02ecc8e9
L
2323 elf_fake_sections. Special handling for .init_array/.fini_array
2324 output sections since they may contain .ctors/.dtors input
2325 sections. We don't want _bfd_elf_init_private_section_data to
2326 copy ELF section type from .ctors/.dtors input sections. */
2327 if (abfd->direction != read_direction
3496cb2a 2328 || (sec->flags & SEC_LINKER_CREATED) != 0)
2f89ff8d 2329 {
551b43fd 2330 ssect = (*bed->get_sec_type_attr) (abfd, sec);
02ecc8e9
L
2331 if (ssect != NULL
2332 && (!sec->flags
2333 || (sec->flags & SEC_LINKER_CREATED) != 0
2334 || ssect->type == SHT_INIT_ARRAY
2335 || ssect->type == SHT_FINI_ARRAY))
a31501e9
L
2336 {
2337 elf_section_type (sec) = ssect->type;
2338 elf_section_flags (sec) = ssect->attr;
2339 }
2f89ff8d
L
2340 }
2341
f592407e 2342 return _bfd_generic_new_section_hook (abfd, sec);
252b5132
RH
2343}
2344
2345/* Create a new bfd section from an ELF program header.
2346
2347 Since program segments have no names, we generate a synthetic name
2348 of the form segment<NUM>, where NUM is generally the index in the
2349 program header table. For segments that are split (see below) we
2350 generate the names segment<NUM>a and segment<NUM>b.
2351
2352 Note that some program segments may have a file size that is different than
2353 (less than) the memory size. All this means is that at execution the
2354 system must allocate the amount of memory specified by the memory size,
2355 but only initialize it with the first "file size" bytes read from the
2356 file. This would occur for example, with program segments consisting
2357 of combined data+bss.
2358
2359 To handle the above situation, this routine generates TWO bfd sections
2360 for the single program segment. The first has the length specified by
2361 the file size of the segment, and the second has the length specified
2362 by the difference between the two sizes. In effect, the segment is split
d5191d0c 2363 into its initialized and uninitialized parts.
252b5132
RH
2364
2365 */
2366
b34976b6 2367bfd_boolean
217aa764
AM
2368_bfd_elf_make_section_from_phdr (bfd *abfd,
2369 Elf_Internal_Phdr *hdr,
91d6fa6a 2370 int hdr_index,
a50b1753 2371 const char *type_name)
252b5132
RH
2372{
2373 asection *newsect;
2374 char *name;
2375 char namebuf[64];
d4c88bbb 2376 size_t len;
252b5132
RH
2377 int split;
2378
2379 split = ((hdr->p_memsz > 0)
2380 && (hdr->p_filesz > 0)
2381 && (hdr->p_memsz > hdr->p_filesz));
d5191d0c
AM
2382
2383 if (hdr->p_filesz > 0)
252b5132 2384 {
91d6fa6a 2385 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "a" : "");
d5191d0c 2386 len = strlen (namebuf) + 1;
a50b1753 2387 name = (char *) bfd_alloc (abfd, len);
d5191d0c
AM
2388 if (!name)
2389 return FALSE;
2390 memcpy (name, namebuf, len);
2391 newsect = bfd_make_section (abfd, name);
2392 if (newsect == NULL)
2393 return FALSE;
2394 newsect->vma = hdr->p_vaddr;
2395 newsect->lma = hdr->p_paddr;
2396 newsect->size = hdr->p_filesz;
2397 newsect->filepos = hdr->p_offset;
2398 newsect->flags |= SEC_HAS_CONTENTS;
2399 newsect->alignment_power = bfd_log2 (hdr->p_align);
2400 if (hdr->p_type == PT_LOAD)
252b5132 2401 {
d5191d0c
AM
2402 newsect->flags |= SEC_ALLOC;
2403 newsect->flags |= SEC_LOAD;
2404 if (hdr->p_flags & PF_X)
2405 {
2406 /* FIXME: all we known is that it has execute PERMISSION,
2407 may be data. */
2408 newsect->flags |= SEC_CODE;
2409 }
2410 }
2411 if (!(hdr->p_flags & PF_W))
2412 {
2413 newsect->flags |= SEC_READONLY;
252b5132 2414 }
252b5132
RH
2415 }
2416
d5191d0c 2417 if (hdr->p_memsz > hdr->p_filesz)
252b5132 2418 {
d5191d0c
AM
2419 bfd_vma align;
2420
91d6fa6a 2421 sprintf (namebuf, "%s%d%s", type_name, hdr_index, split ? "b" : "");
d4c88bbb 2422 len = strlen (namebuf) + 1;
a50b1753 2423 name = (char *) bfd_alloc (abfd, len);
252b5132 2424 if (!name)
b34976b6 2425 return FALSE;
d4c88bbb 2426 memcpy (name, namebuf, len);
252b5132
RH
2427 newsect = bfd_make_section (abfd, name);
2428 if (newsect == NULL)
b34976b6 2429 return FALSE;
252b5132
RH
2430 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2431 newsect->lma = hdr->p_paddr + hdr->p_filesz;
eea6121a 2432 newsect->size = hdr->p_memsz - hdr->p_filesz;
d5191d0c
AM
2433 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2434 align = newsect->vma & -newsect->vma;
2435 if (align == 0 || align > hdr->p_align)
2436 align = hdr->p_align;
2437 newsect->alignment_power = bfd_log2 (align);
252b5132
RH
2438 if (hdr->p_type == PT_LOAD)
2439 {
d5191d0c
AM
2440 /* Hack for gdb. Segments that have not been modified do
2441 not have their contents written to a core file, on the
2442 assumption that a debugger can find the contents in the
2443 executable. We flag this case by setting the fake
2444 section size to zero. Note that "real" bss sections will
2445 always have their contents dumped to the core file. */
2446 if (bfd_get_format (abfd) == bfd_core)
2447 newsect->size = 0;
252b5132
RH
2448 newsect->flags |= SEC_ALLOC;
2449 if (hdr->p_flags & PF_X)
2450 newsect->flags |= SEC_CODE;
2451 }
2452 if (!(hdr->p_flags & PF_W))
2453 newsect->flags |= SEC_READONLY;
2454 }
2455
b34976b6 2456 return TRUE;
252b5132
RH
2457}
2458
b34976b6 2459bfd_boolean
91d6fa6a 2460bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int hdr_index)
20cfcaae 2461{
9c5bfbb7 2462 const struct elf_backend_data *bed;
20cfcaae
NC
2463
2464 switch (hdr->p_type)
2465 {
2466 case PT_NULL:
91d6fa6a 2467 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "null");
20cfcaae
NC
2468
2469 case PT_LOAD:
91d6fa6a 2470 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "load");
20cfcaae
NC
2471
2472 case PT_DYNAMIC:
91d6fa6a 2473 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "dynamic");
20cfcaae
NC
2474
2475 case PT_INTERP:
91d6fa6a 2476 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "interp");
20cfcaae
NC
2477
2478 case PT_NOTE:
91d6fa6a 2479 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "note"))
b34976b6 2480 return FALSE;
718175fa 2481 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
b34976b6
AM
2482 return FALSE;
2483 return TRUE;
20cfcaae
NC
2484
2485 case PT_SHLIB:
91d6fa6a 2486 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "shlib");
20cfcaae
NC
2487
2488 case PT_PHDR:
91d6fa6a 2489 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "phdr");
20cfcaae 2490
811072d8 2491 case PT_GNU_EH_FRAME:
91d6fa6a 2492 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index,
811072d8
RM
2493 "eh_frame_hdr");
2494
2b05f1b7 2495 case PT_GNU_STACK:
91d6fa6a 2496 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "stack");
9ee5e499 2497
8c37241b 2498 case PT_GNU_RELRO:
91d6fa6a 2499 return _bfd_elf_make_section_from_phdr (abfd, hdr, hdr_index, "relro");
8c37241b 2500
20cfcaae 2501 default:
8c1acd09 2502 /* Check for any processor-specific program segment types. */
20cfcaae 2503 bed = get_elf_backend_data (abfd);
91d6fa6a 2504 return bed->elf_backend_section_from_phdr (abfd, hdr, hdr_index, "proc");
20cfcaae
NC
2505 }
2506}
2507
d4730f92
BS
2508/* Return the REL_HDR for SEC, assuming there is only a single one, either
2509 REL or RELA. */
2510
2511Elf_Internal_Shdr *
2512_bfd_elf_single_rel_hdr (asection *sec)
2513{
2514 if (elf_section_data (sec)->rel.hdr)
2515 {
2516 BFD_ASSERT (elf_section_data (sec)->rela.hdr == NULL);
2517 return elf_section_data (sec)->rel.hdr;
2518 }
2519 else
2520 return elf_section_data (sec)->rela.hdr;
2521}
2522
2523/* Allocate and initialize a section-header for a new reloc section,
2524 containing relocations against ASECT. It is stored in RELDATA. If
2525 USE_RELA_P is TRUE, we use RELA relocations; otherwise, we use REL
2526 relocations. */
23bc299b 2527
5d13b3b3 2528static bfd_boolean
217aa764 2529_bfd_elf_init_reloc_shdr (bfd *abfd,
d4730f92 2530 struct bfd_elf_section_reloc_data *reldata,
217aa764
AM
2531 asection *asect,
2532 bfd_boolean use_rela_p)
23bc299b 2533{
d4730f92 2534 Elf_Internal_Shdr *rel_hdr;
23bc299b 2535 char *name;
9c5bfbb7 2536 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
d4730f92
BS
2537 bfd_size_type amt;
2538
2539 amt = sizeof (Elf_Internal_Shdr);
2540 BFD_ASSERT (reldata->hdr == NULL);
2541 rel_hdr = bfd_zalloc (abfd, amt);
2542 reldata->hdr = rel_hdr;
23bc299b 2543
d324f6d6 2544 amt = sizeof ".rela" + strlen (asect->name);
a50b1753 2545 name = (char *) bfd_alloc (abfd, amt);
23bc299b 2546 if (name == NULL)
b34976b6 2547 return FALSE;
23bc299b
MM
2548 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2549 rel_hdr->sh_name =
2b0f7ef9 2550 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
b34976b6 2551 FALSE);
23bc299b 2552 if (rel_hdr->sh_name == (unsigned int) -1)
b34976b6 2553 return FALSE;
23bc299b
MM
2554 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2555 rel_hdr->sh_entsize = (use_rela_p
2556 ? bed->s->sizeof_rela
2557 : bed->s->sizeof_rel);
72de5009 2558 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
23bc299b
MM
2559 rel_hdr->sh_flags = 0;
2560 rel_hdr->sh_addr = 0;
2561 rel_hdr->sh_size = 0;
2562 rel_hdr->sh_offset = 0;
2563
b34976b6 2564 return TRUE;
23bc299b
MM
2565}
2566
94be91de
JB
2567/* Return the default section type based on the passed in section flags. */
2568
2569int
2570bfd_elf_get_default_section_type (flagword flags)
2571{
2572 if ((flags & SEC_ALLOC) != 0
2e76e85a 2573 && (flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
94be91de
JB
2574 return SHT_NOBITS;
2575 return SHT_PROGBITS;
2576}
2577
d4730f92
BS
2578struct fake_section_arg
2579{
2580 struct bfd_link_info *link_info;
2581 bfd_boolean failed;
2582};
2583
252b5132
RH
2584/* Set up an ELF internal section header for a section. */
2585
252b5132 2586static void
d4730f92 2587elf_fake_sections (bfd *abfd, asection *asect, void *fsarg)
252b5132 2588{
d4730f92 2589 struct fake_section_arg *arg = (struct fake_section_arg *)fsarg;
9c5bfbb7 2590 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
d4730f92 2591 struct bfd_elf_section_data *esd = elf_section_data (asect);
252b5132 2592 Elf_Internal_Shdr *this_hdr;
0414f35b 2593 unsigned int sh_type;
252b5132 2594
d4730f92 2595 if (arg->failed)
252b5132
RH
2596 {
2597 /* We already failed; just get out of the bfd_map_over_sections
08a40648 2598 loop. */
252b5132
RH
2599 return;
2600 }
2601
d4730f92 2602 this_hdr = &esd->this_hdr;
252b5132 2603
e57b5356
AM
2604 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2605 asect->name, FALSE);
2606 if (this_hdr->sh_name == (unsigned int) -1)
252b5132 2607 {
d4730f92 2608 arg->failed = TRUE;
252b5132
RH
2609 return;
2610 }
2611
a4d8e49b 2612 /* Don't clear sh_flags. Assembler may set additional bits. */
252b5132
RH
2613
2614 if ((asect->flags & SEC_ALLOC) != 0
2615 || asect->user_set_vma)
2616 this_hdr->sh_addr = asect->vma;
2617 else
2618 this_hdr->sh_addr = 0;
2619
2620 this_hdr->sh_offset = 0;
eea6121a 2621 this_hdr->sh_size = asect->size;
252b5132 2622 this_hdr->sh_link = 0;
72de5009 2623 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
252b5132
RH
2624 /* The sh_entsize and sh_info fields may have been set already by
2625 copy_private_section_data. */
2626
2627 this_hdr->bfd_section = asect;
2628 this_hdr->contents = NULL;
2629
3cddba1e
L
2630 /* If the section type is unspecified, we set it based on
2631 asect->flags. */
98ece1b3
AM
2632 if ((asect->flags & SEC_GROUP) != 0)
2633 sh_type = SHT_GROUP;
98ece1b3 2634 else
94be91de 2635 sh_type = bfd_elf_get_default_section_type (asect->flags);
98ece1b3 2636
3cddba1e 2637 if (this_hdr->sh_type == SHT_NULL)
98ece1b3
AM
2638 this_hdr->sh_type = sh_type;
2639 else if (this_hdr->sh_type == SHT_NOBITS
2640 && sh_type == SHT_PROGBITS
2641 && (asect->flags & SEC_ALLOC) != 0)
3cddba1e 2642 {
98ece1b3
AM
2643 /* Warn if we are changing a NOBITS section to PROGBITS, but
2644 allow the link to proceed. This can happen when users link
2645 non-bss input sections to bss output sections, or emit data
2646 to a bss output section via a linker script. */
2647 (*_bfd_error_handler)
58f0869b 2648 (_("warning: section `%A' type changed to PROGBITS"), asect);
98ece1b3 2649 this_hdr->sh_type = sh_type;
3cddba1e
L
2650 }
2651
2f89ff8d 2652 switch (this_hdr->sh_type)
252b5132 2653 {
2f89ff8d 2654 default:
2f89ff8d
L
2655 break;
2656
2657 case SHT_STRTAB:
2658 case SHT_INIT_ARRAY:
2659 case SHT_FINI_ARRAY:
2660 case SHT_PREINIT_ARRAY:
2661 case SHT_NOTE:
2662 case SHT_NOBITS:
2663 case SHT_PROGBITS:
2664 break;
2665
2666 case SHT_HASH:
c7ac6ff8 2667 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2f89ff8d 2668 break;
5de3bf90 2669
2f89ff8d 2670 case SHT_DYNSYM:
252b5132 2671 this_hdr->sh_entsize = bed->s->sizeof_sym;
2f89ff8d
L
2672 break;
2673
2674 case SHT_DYNAMIC:
252b5132 2675 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2f89ff8d
L
2676 break;
2677
2678 case SHT_RELA:
2679 if (get_elf_backend_data (abfd)->may_use_rela_p)
2680 this_hdr->sh_entsize = bed->s->sizeof_rela;
2681 break;
2682
2683 case SHT_REL:
2684 if (get_elf_backend_data (abfd)->may_use_rel_p)
2685 this_hdr->sh_entsize = bed->s->sizeof_rel;
2686 break;
2687
2688 case SHT_GNU_versym:
252b5132 2689 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2f89ff8d
L
2690 break;
2691
2692 case SHT_GNU_verdef:
252b5132
RH
2693 this_hdr->sh_entsize = 0;
2694 /* objcopy or strip will copy over sh_info, but may not set
08a40648
AM
2695 cverdefs. The linker will set cverdefs, but sh_info will be
2696 zero. */
252b5132
RH
2697 if (this_hdr->sh_info == 0)
2698 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2699 else
2700 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2701 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2f89ff8d
L
2702 break;
2703
2704 case SHT_GNU_verneed:
252b5132
RH
2705 this_hdr->sh_entsize = 0;
2706 /* objcopy or strip will copy over sh_info, but may not set
08a40648
AM
2707 cverrefs. The linker will set cverrefs, but sh_info will be
2708 zero. */
252b5132
RH
2709 if (this_hdr->sh_info == 0)
2710 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2711 else
2712 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2713 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2f89ff8d
L
2714 break;
2715
2716 case SHT_GROUP:
1783205a 2717 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2f89ff8d 2718 break;
fdc90cb4
JJ
2719
2720 case SHT_GNU_HASH:
2721 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2722 break;
dbb410c3 2723 }
252b5132
RH
2724
2725 if ((asect->flags & SEC_ALLOC) != 0)
2726 this_hdr->sh_flags |= SHF_ALLOC;
2727 if ((asect->flags & SEC_READONLY) == 0)
2728 this_hdr->sh_flags |= SHF_WRITE;
2729 if ((asect->flags & SEC_CODE) != 0)
2730 this_hdr->sh_flags |= SHF_EXECINSTR;
f5fa8ca2
JJ
2731 if ((asect->flags & SEC_MERGE) != 0)
2732 {
2733 this_hdr->sh_flags |= SHF_MERGE;
2734 this_hdr->sh_entsize = asect->entsize;
2735 if ((asect->flags & SEC_STRINGS) != 0)
2736 this_hdr->sh_flags |= SHF_STRINGS;
2737 }
1126897b 2738 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
dbb410c3 2739 this_hdr->sh_flags |= SHF_GROUP;
13ae64f3 2740 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
704afa60
JJ
2741 {
2742 this_hdr->sh_flags |= SHF_TLS;
3a800eb9
AM
2743 if (asect->size == 0
2744 && (asect->flags & SEC_HAS_CONTENTS) == 0)
704afa60 2745 {
3a800eb9 2746 struct bfd_link_order *o = asect->map_tail.link_order;
b34976b6 2747
704afa60 2748 this_hdr->sh_size = 0;
3a800eb9
AM
2749 if (o != NULL)
2750 {
704afa60 2751 this_hdr->sh_size = o->offset + o->size;
3a800eb9
AM
2752 if (this_hdr->sh_size != 0)
2753 this_hdr->sh_type = SHT_NOBITS;
2754 }
704afa60
JJ
2755 }
2756 }
18ae9cc1
L
2757 if ((asect->flags & (SEC_GROUP | SEC_EXCLUDE)) == SEC_EXCLUDE)
2758 this_hdr->sh_flags |= SHF_EXCLUDE;
252b5132 2759
d4730f92
BS
2760 /* If the section has relocs, set up a section header for the
2761 SHT_REL[A] section. If two relocation sections are required for
2762 this section, it is up to the processor-specific back-end to
2763 create the other. */
2764 if ((asect->flags & SEC_RELOC) != 0)
2765 {
2766 /* When doing a relocatable link, create both REL and RELA sections if
2767 needed. */
2768 if (arg->link_info
2769 /* Do the normal setup if we wouldn't create any sections here. */
2770 && esd->rel.count + esd->rela.count > 0
2771 && (arg->link_info->relocatable || arg->link_info->emitrelocations))
2772 {
2773 if (esd->rel.count && esd->rel.hdr == NULL
2774 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rel, asect, FALSE))
2775 {
2776 arg->failed = TRUE;
2777 return;
2778 }
2779 if (esd->rela.count && esd->rela.hdr == NULL
2780 && !_bfd_elf_init_reloc_shdr (abfd, &esd->rela, asect, TRUE))
2781 {
2782 arg->failed = TRUE;
2783 return;
2784 }
2785 }
2786 else if (!_bfd_elf_init_reloc_shdr (abfd,
2787 (asect->use_rela_p
2788 ? &esd->rela : &esd->rel),
2789 asect,
2790 asect->use_rela_p))
2791 arg->failed = TRUE;
2792 }
2793
252b5132 2794 /* Check for processor-specific section types. */
0414f35b 2795 sh_type = this_hdr->sh_type;
e1fddb6b
AO
2796 if (bed->elf_backend_fake_sections
2797 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
d4730f92 2798 arg->failed = TRUE;
252b5132 2799
42bb2e33 2800 if (sh_type == SHT_NOBITS && asect->size != 0)
0414f35b
AM
2801 {
2802 /* Don't change the header type from NOBITS if we are being
42bb2e33 2803 called for objcopy --only-keep-debug. */
0414f35b
AM
2804 this_hdr->sh_type = sh_type;
2805 }
252b5132
RH
2806}
2807
bcacc0f5
AM
2808/* Fill in the contents of a SHT_GROUP section. Called from
2809 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2810 when ELF targets use the generic linker, ld. Called for ld -r
2811 from bfd_elf_final_link. */
dbb410c3 2812
1126897b 2813void
217aa764 2814bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
dbb410c3 2815{
a50b1753 2816 bfd_boolean *failedptr = (bfd_boolean *) failedptrarg;
9dce4196 2817 asection *elt, *first;
dbb410c3 2818 unsigned char *loc;
b34976b6 2819 bfd_boolean gas;
dbb410c3 2820
7e4111ad
L
2821 /* Ignore linker created group section. See elfNN_ia64_object_p in
2822 elfxx-ia64.c. */
2823 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
dbb410c3
AM
2824 || *failedptr)
2825 return;
2826
bcacc0f5
AM
2827 if (elf_section_data (sec)->this_hdr.sh_info == 0)
2828 {
2829 unsigned long symindx = 0;
2830
2831 /* elf_group_id will have been set up by objcopy and the
2832 generic linker. */
2833 if (elf_group_id (sec) != NULL)
2834 symindx = elf_group_id (sec)->udata.i;
1126897b 2835
bcacc0f5
AM
2836 if (symindx == 0)
2837 {
2838 /* If called from the assembler, swap_out_syms will have set up
2839 elf_section_syms. */
2840 BFD_ASSERT (elf_section_syms (abfd) != NULL);
2841 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2842 }
2843 elf_section_data (sec)->this_hdr.sh_info = symindx;
2844 }
2845 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
1126897b 2846 {
bcacc0f5
AM
2847 /* The ELF backend linker sets sh_info to -2 when the group
2848 signature symbol is global, and thus the index can't be
2849 set until all local symbols are output. */
2850 asection *igroup = elf_sec_group (elf_next_in_group (sec));
2851 struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2852 unsigned long symndx = sec_data->this_hdr.sh_info;
2853 unsigned long extsymoff = 0;
2854 struct elf_link_hash_entry *h;
2855
2856 if (!elf_bad_symtab (igroup->owner))
2857 {
2858 Elf_Internal_Shdr *symtab_hdr;
2859
2860 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2861 extsymoff = symtab_hdr->sh_info;
2862 }
2863 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2864 while (h->root.type == bfd_link_hash_indirect
2865 || h->root.type == bfd_link_hash_warning)
2866 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2867
2868 elf_section_data (sec)->this_hdr.sh_info = h->indx;
1126897b 2869 }
dbb410c3 2870
1126897b 2871 /* The contents won't be allocated for "ld -r" or objcopy. */
b34976b6 2872 gas = TRUE;
dbb410c3
AM
2873 if (sec->contents == NULL)
2874 {
b34976b6 2875 gas = FALSE;
a50b1753 2876 sec->contents = (unsigned char *) bfd_alloc (abfd, sec->size);
9dce4196
AM
2877
2878 /* Arrange for the section to be written out. */
2879 elf_section_data (sec)->this_hdr.contents = sec->contents;
dbb410c3
AM
2880 if (sec->contents == NULL)
2881 {
b34976b6 2882 *failedptr = TRUE;
dbb410c3
AM
2883 return;
2884 }
2885 }
2886
eea6121a 2887 loc = sec->contents + sec->size;
dbb410c3 2888
9dce4196
AM
2889 /* Get the pointer to the first section in the group that gas
2890 squirreled away here. objcopy arranges for this to be set to the
2891 start of the input section group. */
2892 first = elt = elf_next_in_group (sec);
dbb410c3
AM
2893
2894 /* First element is a flag word. Rest of section is elf section
2895 indices for all the sections of the group. Write them backwards
2896 just to keep the group in the same order as given in .section
2897 directives, not that it matters. */
2898 while (elt != NULL)
2899 {
9dce4196 2900 asection *s;
9dce4196 2901
9dce4196 2902 s = elt;
415f38a6
AM
2903 if (!gas)
2904 s = s->output_section;
2905 if (s != NULL
2906 && !bfd_is_abs_section (s))
01e1a5bc 2907 {
415f38a6
AM
2908 unsigned int idx = elf_section_data (s)->this_idx;
2909
01e1a5bc 2910 loc -= 4;
01e1a5bc
NC
2911 H_PUT_32 (abfd, idx, loc);
2912 }
945906ff 2913 elt = elf_next_in_group (elt);
9dce4196
AM
2914 if (elt == first)
2915 break;
dbb410c3
AM
2916 }
2917
3d7f7666 2918 if ((loc -= 4) != sec->contents)
9dce4196 2919 abort ();
dbb410c3 2920
9dce4196 2921 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
dbb410c3
AM
2922}
2923
252b5132
RH
2924/* Assign all ELF section numbers. The dummy first section is handled here
2925 too. The link/info pointers for the standard section types are filled
2926 in here too, while we're at it. */
2927
b34976b6 2928static bfd_boolean
da9f89d4 2929assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
252b5132
RH
2930{
2931 struct elf_obj_tdata *t = elf_tdata (abfd);
2932 asection *sec;
2b0f7ef9 2933 unsigned int section_number, secn;
252b5132 2934 Elf_Internal_Shdr **i_shdrp;
47cc2cf5 2935 struct bfd_elf_section_data *d;
3516e984 2936 bfd_boolean need_symtab;
252b5132
RH
2937
2938 section_number = 1;
2939
2b0f7ef9
JJ
2940 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2941
da9f89d4
L
2942 /* SHT_GROUP sections are in relocatable files only. */
2943 if (link_info == NULL || link_info->relocatable)
252b5132 2944 {
da9f89d4 2945 /* Put SHT_GROUP sections first. */
04dd1667 2946 for (sec = abfd->sections; sec != NULL; sec = sec->next)
47cc2cf5 2947 {
5daa8fe7 2948 d = elf_section_data (sec);
da9f89d4
L
2949
2950 if (d->this_hdr.sh_type == SHT_GROUP)
08a40648 2951 {
5daa8fe7 2952 if (sec->flags & SEC_LINKER_CREATED)
da9f89d4
L
2953 {
2954 /* Remove the linker created SHT_GROUP sections. */
5daa8fe7 2955 bfd_section_list_remove (abfd, sec);
da9f89d4 2956 abfd->section_count--;
da9f89d4 2957 }
08a40648 2958 else
4fbb74a6 2959 d->this_idx = section_number++;
da9f89d4 2960 }
47cc2cf5
PB
2961 }
2962 }
2963
2964 for (sec = abfd->sections; sec; sec = sec->next)
2965 {
2966 d = elf_section_data (sec);
2967
2968 if (d->this_hdr.sh_type != SHT_GROUP)
4fbb74a6 2969 d->this_idx = section_number++;
2b0f7ef9 2970 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
d4730f92 2971 if (d->rel.hdr)
2b0f7ef9 2972 {
d4730f92
BS
2973 d->rel.idx = section_number++;
2974 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel.hdr->sh_name);
2b0f7ef9 2975 }
d4730f92
BS
2976 else
2977 d->rel.idx = 0;
23bc299b 2978
d4730f92 2979 if (d->rela.hdr)
2b0f7ef9 2980 {
d4730f92
BS
2981 d->rela.idx = section_number++;
2982 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rela.hdr->sh_name);
2b0f7ef9 2983 }
23bc299b 2984 else
d4730f92 2985 d->rela.idx = 0;
252b5132
RH
2986 }
2987
12bd6957 2988 elf_shstrtab_sec (abfd) = section_number++;
2b0f7ef9 2989 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
12bd6957 2990 elf_elfheader (abfd)->e_shstrndx = elf_shstrtab_sec (abfd);
252b5132 2991
3516e984
L
2992 need_symtab = (bfd_get_symcount (abfd) > 0
2993 || (link_info == NULL
2994 && ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
2995 == HAS_RELOC)));
2996 if (need_symtab)
252b5132 2997 {
12bd6957 2998 elf_onesymtab (abfd) = section_number++;
2b0f7ef9 2999 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
4fbb74a6 3000 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
9ad5cbcf 3001 {
12bd6957 3002 elf_symtab_shndx (abfd) = section_number++;
9ad5cbcf
AM
3003 t->symtab_shndx_hdr.sh_name
3004 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
b34976b6 3005 ".symtab_shndx", FALSE);
9ad5cbcf 3006 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
b34976b6 3007 return FALSE;
9ad5cbcf 3008 }
12bd6957 3009 elf_strtab_sec (abfd) = section_number++;
2b0f7ef9 3010 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
252b5132
RH
3011 }
3012
1c52a645
L
3013 if (section_number >= SHN_LORESERVE)
3014 {
3015 _bfd_error_handler (_("%B: too many sections: %u"),
3016 abfd, section_number);
3017 return FALSE;
3018 }
3019
2b0f7ef9
JJ
3020 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
3021 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
9ad5cbcf
AM
3022
3023 elf_numsections (abfd) = section_number;
252b5132
RH
3024 elf_elfheader (abfd)->e_shnum = section_number;
3025
3026 /* Set up the list of section header pointers, in agreement with the
3027 indices. */
a50b1753
NC
3028 i_shdrp = (Elf_Internal_Shdr **) bfd_zalloc2 (abfd, section_number,
3029 sizeof (Elf_Internal_Shdr *));
252b5132 3030 if (i_shdrp == NULL)
b34976b6 3031 return FALSE;
252b5132 3032
a50b1753
NC
3033 i_shdrp[0] = (Elf_Internal_Shdr *) bfd_zalloc (abfd,
3034 sizeof (Elf_Internal_Shdr));
252b5132
RH
3035 if (i_shdrp[0] == NULL)
3036 {
3037 bfd_release (abfd, i_shdrp);
b34976b6 3038 return FALSE;
252b5132 3039 }
252b5132
RH
3040
3041 elf_elfsections (abfd) = i_shdrp;
3042
12bd6957 3043 i_shdrp[elf_shstrtab_sec (abfd)] = &t->shstrtab_hdr;
3516e984 3044 if (need_symtab)
252b5132 3045 {
12bd6957 3046 i_shdrp[elf_onesymtab (abfd)] = &t->symtab_hdr;
4fbb74a6 3047 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
9ad5cbcf 3048 {
12bd6957
AM
3049 i_shdrp[elf_symtab_shndx (abfd)] = &t->symtab_shndx_hdr;
3050 t->symtab_shndx_hdr.sh_link = elf_onesymtab (abfd);
9ad5cbcf 3051 }
12bd6957
AM
3052 i_shdrp[elf_strtab_sec (abfd)] = &t->strtab_hdr;
3053 t->symtab_hdr.sh_link = elf_strtab_sec (abfd);
252b5132 3054 }
38ce5b11 3055
252b5132
RH
3056 for (sec = abfd->sections; sec; sec = sec->next)
3057 {
252b5132
RH
3058 asection *s;
3059 const char *name;
3060
91d6fa6a
NC
3061 d = elf_section_data (sec);
3062
252b5132 3063 i_shdrp[d->this_idx] = &d->this_hdr;
d4730f92
BS
3064 if (d->rel.idx != 0)
3065 i_shdrp[d->rel.idx] = d->rel.hdr;
3066 if (d->rela.idx != 0)
3067 i_shdrp[d->rela.idx] = d->rela.hdr;
252b5132
RH
3068
3069 /* Fill in the sh_link and sh_info fields while we're at it. */
3070
3071 /* sh_link of a reloc section is the section index of the symbol
3072 table. sh_info is the section index of the section to which
3073 the relocation entries apply. */
d4730f92 3074 if (d->rel.idx != 0)
252b5132 3075 {
12bd6957 3076 d->rel.hdr->sh_link = elf_onesymtab (abfd);
d4730f92 3077 d->rel.hdr->sh_info = d->this_idx;
9ef5d938 3078 d->rel.hdr->sh_flags |= SHF_INFO_LINK;
252b5132 3079 }
d4730f92 3080 if (d->rela.idx != 0)
23bc299b 3081 {
12bd6957 3082 d->rela.hdr->sh_link = elf_onesymtab (abfd);
d4730f92 3083 d->rela.hdr->sh_info = d->this_idx;
9ef5d938 3084 d->rela.hdr->sh_flags |= SHF_INFO_LINK;
23bc299b 3085 }
252b5132 3086
38ce5b11
L
3087 /* We need to set up sh_link for SHF_LINK_ORDER. */
3088 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
3089 {
3090 s = elf_linked_to_section (sec);
3091 if (s)
38ce5b11 3092 {
f2876037 3093 /* elf_linked_to_section points to the input section. */
ccd2ec6a 3094 if (link_info != NULL)
38ce5b11 3095 {
f2876037 3096 /* Check discarded linkonce section. */
dbaa2011 3097 if (discarded_section (s))
38ce5b11 3098 {
ccd2ec6a
L
3099 asection *kept;
3100 (*_bfd_error_handler)
3101 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
3102 abfd, d->this_hdr.bfd_section,
3103 s, s->owner);
3104 /* Point to the kept section if it has the same
3105 size as the discarded one. */
c0f00686 3106 kept = _bfd_elf_check_kept_section (s, link_info);
ccd2ec6a 3107 if (kept == NULL)
185d09ad 3108 {
ccd2ec6a
L
3109 bfd_set_error (bfd_error_bad_value);
3110 return FALSE;
185d09ad 3111 }
ccd2ec6a 3112 s = kept;
38ce5b11 3113 }
e424ecc8 3114
ccd2ec6a
L
3115 s = s->output_section;
3116 BFD_ASSERT (s != NULL);
38ce5b11 3117 }
f2876037
L
3118 else
3119 {
3120 /* Handle objcopy. */
3121 if (s->output_section == NULL)
3122 {
3123 (*_bfd_error_handler)
3124 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
3125 abfd, d->this_hdr.bfd_section, s, s->owner);
3126 bfd_set_error (bfd_error_bad_value);
3127 return FALSE;
3128 }
3129 s = s->output_section;
3130 }
ccd2ec6a
L
3131 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3132 }
3133 else
3134 {
3135 /* PR 290:
3136 The Intel C compiler generates SHT_IA_64_UNWIND with
3137 SHF_LINK_ORDER. But it doesn't set the sh_link or
3138 sh_info fields. Hence we could get the situation
08a40648 3139 where s is NULL. */
ccd2ec6a
L
3140 const struct elf_backend_data *bed
3141 = get_elf_backend_data (abfd);
3142 if (bed->link_order_error_handler)
3143 bed->link_order_error_handler
3144 (_("%B: warning: sh_link not set for section `%A'"),
3145 abfd, sec);
38ce5b11
L
3146 }
3147 }
3148
252b5132
RH
3149 switch (d->this_hdr.sh_type)
3150 {
3151 case SHT_REL:
3152 case SHT_RELA:
3153 /* A reloc section which we are treating as a normal BFD
3154 section. sh_link is the section index of the symbol
3155 table. sh_info is the section index of the section to
3156 which the relocation entries apply. We assume that an
3157 allocated reloc section uses the dynamic symbol table.
3158 FIXME: How can we be sure? */
3159 s = bfd_get_section_by_name (abfd, ".dynsym");
3160 if (s != NULL)
3161 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3162
3163 /* We look up the section the relocs apply to by name. */
3164 name = sec->name;
3165 if (d->this_hdr.sh_type == SHT_REL)
3166 name += 4;
3167 else
3168 name += 5;
3169 s = bfd_get_section_by_name (abfd, name);
3170 if (s != NULL)
9ef5d938
L
3171 {
3172 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
3173 d->this_hdr.sh_flags |= SHF_INFO_LINK;
3174 }
252b5132
RH
3175 break;
3176
3177 case SHT_STRTAB:
3178 /* We assume that a section named .stab*str is a stabs
3179 string section. We look for a section with the same name
3180 but without the trailing ``str'', and set its sh_link
3181 field to point to this section. */
0112cd26 3182 if (CONST_STRNEQ (sec->name, ".stab")
252b5132
RH
3183 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3184 {
3185 size_t len;
3186 char *alc;
3187
3188 len = strlen (sec->name);
a50b1753 3189 alc = (char *) bfd_malloc (len - 2);
252b5132 3190 if (alc == NULL)
b34976b6 3191 return FALSE;
d4c88bbb 3192 memcpy (alc, sec->name, len - 3);
252b5132
RH
3193 alc[len - 3] = '\0';
3194 s = bfd_get_section_by_name (abfd, alc);
3195 free (alc);
3196 if (s != NULL)
3197 {
3198 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3199
3200 /* This is a .stab section. */
0594c12d
AM
3201 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3202 elf_section_data (s)->this_hdr.sh_entsize
3203 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
252b5132
RH
3204 }
3205 }
3206 break;
3207
3208 case SHT_DYNAMIC:
3209 case SHT_DYNSYM:
3210 case SHT_GNU_verneed:
3211 case SHT_GNU_verdef:
3212 /* sh_link is the section header index of the string table
3213 used for the dynamic entries, or the symbol table, or the
3214 version strings. */
3215 s = bfd_get_section_by_name (abfd, ".dynstr");
3216 if (s != NULL)
3217 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3218 break;
3219
7f1204bb
JJ
3220 case SHT_GNU_LIBLIST:
3221 /* sh_link is the section header index of the prelink library
08a40648
AM
3222 list used for the dynamic entries, or the symbol table, or
3223 the version strings. */
7f1204bb
JJ
3224 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3225 ? ".dynstr" : ".gnu.libstr");
3226 if (s != NULL)
3227 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3228 break;
3229
252b5132 3230 case SHT_HASH:
fdc90cb4 3231 case SHT_GNU_HASH:
252b5132
RH
3232 case SHT_GNU_versym:
3233 /* sh_link is the section header index of the symbol table
3234 this hash table or version table is for. */
3235 s = bfd_get_section_by_name (abfd, ".dynsym");
3236 if (s != NULL)
3237 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3238 break;
dbb410c3
AM
3239
3240 case SHT_GROUP:
12bd6957 3241 d->this_hdr.sh_link = elf_onesymtab (abfd);
252b5132
RH
3242 }
3243 }
3244
2b0f7ef9 3245 for (secn = 1; secn < section_number; ++secn)
9ad5cbcf
AM
3246 if (i_shdrp[secn] == NULL)
3247 i_shdrp[secn] = i_shdrp[0];
3248 else
3249 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3250 i_shdrp[secn]->sh_name);
b34976b6 3251 return TRUE;
252b5132
RH
3252}
3253
5372391b 3254static bfd_boolean
217aa764 3255sym_is_global (bfd *abfd, asymbol *sym)
252b5132
RH
3256{
3257 /* If the backend has a special mapping, use it. */
9c5bfbb7 3258 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764
AM
3259 if (bed->elf_backend_sym_is_global)
3260 return (*bed->elf_backend_sym_is_global) (abfd, sym);
252b5132 3261
e47bf690 3262 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK | BSF_GNU_UNIQUE)) != 0
252b5132
RH
3263 || bfd_is_und_section (bfd_get_section (sym))
3264 || bfd_is_com_section (bfd_get_section (sym)));
3265}
3266
5372391b 3267/* Don't output section symbols for sections that are not going to be
c6d8cab4 3268 output, that are duplicates or there is no BFD section. */
5372391b
AM
3269
3270static bfd_boolean
3271ignore_section_sym (bfd *abfd, asymbol *sym)
3272{
c6d8cab4
L
3273 elf_symbol_type *type_ptr;
3274
3275 if ((sym->flags & BSF_SECTION_SYM) == 0)
3276 return FALSE;
3277
3278 type_ptr = elf_symbol_from (abfd, sym);
3279 return ((type_ptr != NULL
3280 && type_ptr->internal_elf_sym.st_shndx != 0
3281 && bfd_is_abs_section (sym->section))
3282 || !(sym->section->owner == abfd
0f0a5e58 3283 || (sym->section->output_section->owner == abfd
2633a79c
AM
3284 && sym->section->output_offset == 0)
3285 || bfd_is_abs_section (sym->section)));
5372391b
AM
3286}
3287
2633a79c
AM
3288/* Map symbol from it's internal number to the external number, moving
3289 all local symbols to be at the head of the list. */
3290
b34976b6 3291static bfd_boolean
12bd6957 3292elf_map_symbols (bfd *abfd, unsigned int *pnum_locals)
252b5132 3293{
dc810e39 3294 unsigned int symcount = bfd_get_symcount (abfd);
252b5132
RH
3295 asymbol **syms = bfd_get_outsymbols (abfd);
3296 asymbol **sect_syms;
dc810e39
AM
3297 unsigned int num_locals = 0;
3298 unsigned int num_globals = 0;
3299 unsigned int num_locals2 = 0;
3300 unsigned int num_globals2 = 0;
252b5132 3301 int max_index = 0;
dc810e39 3302 unsigned int idx;
252b5132
RH
3303 asection *asect;
3304 asymbol **new_syms;
252b5132
RH
3305
3306#ifdef DEBUG
3307 fprintf (stderr, "elf_map_symbols\n");
3308 fflush (stderr);
3309#endif
3310
252b5132
RH
3311 for (asect = abfd->sections; asect; asect = asect->next)
3312 {
3313 if (max_index < asect->index)
3314 max_index = asect->index;
3315 }
3316
3317 max_index++;
a50b1753 3318 sect_syms = (asymbol **) bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
252b5132 3319 if (sect_syms == NULL)
b34976b6 3320 return FALSE;
252b5132 3321 elf_section_syms (abfd) = sect_syms;
4e89ac30 3322 elf_num_section_syms (abfd) = max_index;
252b5132 3323
079e9a2f
AM
3324 /* Init sect_syms entries for any section symbols we have already
3325 decided to output. */
252b5132
RH
3326 for (idx = 0; idx < symcount; idx++)
3327 {
dc810e39 3328 asymbol *sym = syms[idx];
c044fabd 3329
252b5132 3330 if ((sym->flags & BSF_SECTION_SYM) != 0
0f0a5e58 3331 && sym->value == 0
2633a79c
AM
3332 && !ignore_section_sym (abfd, sym)
3333 && !bfd_is_abs_section (sym->section))
252b5132 3334 {
5372391b 3335 asection *sec = sym->section;
252b5132 3336
5372391b
AM
3337 if (sec->owner != abfd)
3338 sec = sec->output_section;
252b5132 3339
5372391b 3340 sect_syms[sec->index] = syms[idx];
252b5132
RH
3341 }
3342 }
3343
252b5132
RH
3344 /* Classify all of the symbols. */
3345 for (idx = 0; idx < symcount; idx++)
3346 {
2633a79c 3347 if (sym_is_global (abfd, syms[idx]))
252b5132 3348 num_globals++;
2633a79c
AM
3349 else if (!ignore_section_sym (abfd, syms[idx]))
3350 num_locals++;
252b5132 3351 }
079e9a2f 3352
5372391b 3353 /* We will be adding a section symbol for each normal BFD section. Most
079e9a2f
AM
3354 sections will already have a section symbol in outsymbols, but
3355 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3356 at least in that case. */
252b5132
RH
3357 for (asect = abfd->sections; asect; asect = asect->next)
3358 {
079e9a2f 3359 if (sect_syms[asect->index] == NULL)
252b5132 3360 {
079e9a2f 3361 if (!sym_is_global (abfd, asect->symbol))
252b5132
RH
3362 num_locals++;
3363 else
3364 num_globals++;
252b5132
RH
3365 }
3366 }
3367
3368 /* Now sort the symbols so the local symbols are first. */
a50b1753
NC
3369 new_syms = (asymbol **) bfd_alloc2 (abfd, num_locals + num_globals,
3370 sizeof (asymbol *));
dc810e39 3371
252b5132 3372 if (new_syms == NULL)
b34976b6 3373 return FALSE;
252b5132
RH
3374
3375 for (idx = 0; idx < symcount; idx++)
3376 {
3377 asymbol *sym = syms[idx];
dc810e39 3378 unsigned int i;
252b5132 3379
2633a79c
AM
3380 if (sym_is_global (abfd, sym))
3381 i = num_locals + num_globals2++;
3382 else if (!ignore_section_sym (abfd, sym))
252b5132
RH
3383 i = num_locals2++;
3384 else
2633a79c 3385 continue;
252b5132
RH
3386 new_syms[i] = sym;
3387 sym->udata.i = i + 1;
3388 }
3389 for (asect = abfd->sections; asect; asect = asect->next)
3390 {
079e9a2f 3391 if (sect_syms[asect->index] == NULL)
252b5132 3392 {
079e9a2f 3393 asymbol *sym = asect->symbol;
dc810e39 3394 unsigned int i;
252b5132 3395
079e9a2f 3396 sect_syms[asect->index] = sym;
252b5132
RH
3397 if (!sym_is_global (abfd, sym))
3398 i = num_locals2++;
3399 else
3400 i = num_locals + num_globals2++;
3401 new_syms[i] = sym;
3402 sym->udata.i = i + 1;
3403 }
3404 }
3405
3406 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3407
12bd6957 3408 *pnum_locals = num_locals;
b34976b6 3409 return TRUE;
252b5132
RH
3410}
3411
3412/* Align to the maximum file alignment that could be required for any
3413 ELF data structure. */
3414
268b6b39 3415static inline file_ptr
217aa764 3416align_file_position (file_ptr off, int align)
252b5132
RH
3417{
3418 return (off + align - 1) & ~(align - 1);
3419}
3420
3421/* Assign a file position to a section, optionally aligning to the
3422 required section alignment. */
3423
217aa764
AM
3424file_ptr
3425_bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3426 file_ptr offset,
3427 bfd_boolean align)
252b5132 3428{
72de5009
AM
3429 if (align && i_shdrp->sh_addralign > 1)
3430 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
252b5132
RH
3431 i_shdrp->sh_offset = offset;
3432 if (i_shdrp->bfd_section != NULL)
3433 i_shdrp->bfd_section->filepos = offset;
3434 if (i_shdrp->sh_type != SHT_NOBITS)
3435 offset += i_shdrp->sh_size;
3436 return offset;
3437}
3438
3439/* Compute the file positions we are going to put the sections at, and
3440 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3441 is not NULL, this is being called by the ELF backend linker. */
3442
b34976b6 3443bfd_boolean
217aa764
AM
3444_bfd_elf_compute_section_file_positions (bfd *abfd,
3445 struct bfd_link_info *link_info)
252b5132 3446{
9c5bfbb7 3447 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
d4730f92 3448 struct fake_section_arg fsargs;
b34976b6 3449 bfd_boolean failed;
4b6c0f2f 3450 struct bfd_strtab_hash *strtab = NULL;
252b5132 3451 Elf_Internal_Shdr *shstrtab_hdr;
3516e984 3452 bfd_boolean need_symtab;
252b5132
RH
3453
3454 if (abfd->output_has_begun)
b34976b6 3455 return TRUE;
252b5132
RH
3456
3457 /* Do any elf backend specific processing first. */
3458 if (bed->elf_backend_begin_write_processing)
3459 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3460
3461 if (! prep_headers (abfd))
b34976b6 3462 return FALSE;
252b5132 3463
e6c51ed4 3464 /* Post process the headers if necessary. */
78245035 3465 (*bed->elf_backend_post_process_headers) (abfd, link_info);
e6c51ed4 3466
d4730f92
BS
3467 fsargs.failed = FALSE;
3468 fsargs.link_info = link_info;
3469 bfd_map_over_sections (abfd, elf_fake_sections, &fsargs);
3470 if (fsargs.failed)
b34976b6 3471 return FALSE;
252b5132 3472
da9f89d4 3473 if (!assign_section_numbers (abfd, link_info))
b34976b6 3474 return FALSE;
252b5132
RH
3475
3476 /* The backend linker builds symbol table information itself. */
3516e984
L
3477 need_symtab = (link_info == NULL
3478 && (bfd_get_symcount (abfd) > 0
3479 || ((abfd->flags & (EXEC_P | DYNAMIC | HAS_RELOC))
3480 == HAS_RELOC)));
3481 if (need_symtab)
252b5132
RH
3482 {
3483 /* Non-zero if doing a relocatable link. */
3484 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3485
3486 if (! swap_out_syms (abfd, &strtab, relocatable_p))
b34976b6 3487 return FALSE;
252b5132
RH
3488 }
3489
d4730f92 3490 failed = FALSE;
1126897b 3491 if (link_info == NULL)
dbb410c3 3492 {
1126897b 3493 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
dbb410c3 3494 if (failed)
b34976b6 3495 return FALSE;
dbb410c3
AM
3496 }
3497
252b5132
RH
3498 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3499 /* sh_name was set in prep_headers. */
3500 shstrtab_hdr->sh_type = SHT_STRTAB;
3501 shstrtab_hdr->sh_flags = 0;
3502 shstrtab_hdr->sh_addr = 0;
2b0f7ef9 3503 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
252b5132
RH
3504 shstrtab_hdr->sh_entsize = 0;
3505 shstrtab_hdr->sh_link = 0;
3506 shstrtab_hdr->sh_info = 0;
3507 /* sh_offset is set in assign_file_positions_except_relocs. */
3508 shstrtab_hdr->sh_addralign = 1;
3509
c84fca4d 3510 if (!assign_file_positions_except_relocs (abfd, link_info))
b34976b6 3511 return FALSE;
252b5132 3512
3516e984 3513 if (need_symtab)
252b5132
RH
3514 {
3515 file_ptr off;
3516 Elf_Internal_Shdr *hdr;
3517
12bd6957 3518 off = elf_next_file_pos (abfd);
252b5132
RH
3519
3520 hdr = &elf_tdata (abfd)->symtab_hdr;
b34976b6 3521 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 3522
9ad5cbcf
AM
3523 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3524 if (hdr->sh_size != 0)
b34976b6 3525 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
9ad5cbcf 3526
252b5132 3527 hdr = &elf_tdata (abfd)->strtab_hdr;
b34976b6 3528 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 3529
12bd6957 3530 elf_next_file_pos (abfd) = off;
252b5132
RH
3531
3532 /* Now that we know where the .strtab section goes, write it
08a40648 3533 out. */
252b5132
RH
3534 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3535 || ! _bfd_stringtab_emit (abfd, strtab))
b34976b6 3536 return FALSE;
252b5132
RH
3537 _bfd_stringtab_free (strtab);
3538 }
3539
b34976b6 3540 abfd->output_has_begun = TRUE;
252b5132 3541
b34976b6 3542 return TRUE;
252b5132
RH
3543}
3544
8ded5a0f
AM
3545/* Make an initial estimate of the size of the program header. If we
3546 get the number wrong here, we'll redo section placement. */
3547
3548static bfd_size_type
3549get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3550{
3551 size_t segs;
3552 asection *s;
2b05f1b7 3553 const struct elf_backend_data *bed;
8ded5a0f
AM
3554
3555 /* Assume we will need exactly two PT_LOAD segments: one for text
3556 and one for data. */
3557 segs = 2;
3558
3559 s = bfd_get_section_by_name (abfd, ".interp");
3560 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3561 {
3562 /* If we have a loadable interpreter section, we need a
3563 PT_INTERP segment. In this case, assume we also need a
3564 PT_PHDR segment, although that may not be true for all
3565 targets. */
3566 segs += 2;
3567 }
3568
3569 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3570 {
3571 /* We need a PT_DYNAMIC segment. */
3572 ++segs;
f210dcff 3573 }
08a40648 3574
ceae84aa 3575 if (info != NULL && info->relro)
f210dcff
L
3576 {
3577 /* We need a PT_GNU_RELRO segment. */
3578 ++segs;
8ded5a0f
AM
3579 }
3580
12bd6957 3581 if (elf_eh_frame_hdr (abfd))
8ded5a0f
AM
3582 {
3583 /* We need a PT_GNU_EH_FRAME segment. */
3584 ++segs;
3585 }
3586
12bd6957 3587 if (elf_stack_flags (abfd))
8ded5a0f 3588 {
2b05f1b7
L
3589 /* We need a PT_GNU_STACK segment. */
3590 ++segs;
3591 }
94b11780 3592
2b05f1b7
L
3593 for (s = abfd->sections; s != NULL; s = s->next)
3594 {
8ded5a0f 3595 if ((s->flags & SEC_LOAD) != 0
0112cd26 3596 && CONST_STRNEQ (s->name, ".note"))
8ded5a0f
AM
3597 {
3598 /* We need a PT_NOTE segment. */
3599 ++segs;
1c5265b5
JJ
3600 /* Try to create just one PT_NOTE segment
3601 for all adjacent loadable .note* sections.
3602 gABI requires that within a PT_NOTE segment
3603 (and also inside of each SHT_NOTE section)
3604 each note is padded to a multiple of 4 size,
3605 so we check whether the sections are correctly
3606 aligned. */
3607 if (s->alignment_power == 2)
3608 while (s->next != NULL
3609 && s->next->alignment_power == 2
3610 && (s->next->flags & SEC_LOAD) != 0
3611 && CONST_STRNEQ (s->next->name, ".note"))
3612 s = s->next;
8ded5a0f
AM
3613 }
3614 }
3615
3616 for (s = abfd->sections; s != NULL; s = s->next)
3617 {
3618 if (s->flags & SEC_THREAD_LOCAL)
3619 {
3620 /* We need a PT_TLS segment. */
3621 ++segs;
3622 break;
3623 }
3624 }
3625
3626 /* Let the backend count up any program headers it might need. */
2b05f1b7 3627 bed = get_elf_backend_data (abfd);
8ded5a0f
AM
3628 if (bed->elf_backend_additional_program_headers)
3629 {
3630 int a;
3631
3632 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3633 if (a == -1)
3634 abort ();
3635 segs += a;
3636 }
3637
3638 return segs * bed->s->sizeof_phdr;
3639}
3640
2ea37f1c
NC
3641/* Find the segment that contains the output_section of section. */
3642
3643Elf_Internal_Phdr *
3644_bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3645{
3646 struct elf_segment_map *m;
3647 Elf_Internal_Phdr *p;
3648
12bd6957 3649 for (m = elf_seg_map (abfd), p = elf_tdata (abfd)->phdr;
2ea37f1c
NC
3650 m != NULL;
3651 m = m->next, p++)
3652 {
3653 int i;
3654
3655 for (i = m->count - 1; i >= 0; i--)
3656 if (m->sections[i] == section)
3657 return p;
3658 }
3659
3660 return NULL;
3661}
3662
252b5132
RH
3663/* Create a mapping from a set of sections to a program segment. */
3664
217aa764
AM
3665static struct elf_segment_map *
3666make_mapping (bfd *abfd,
3667 asection **sections,
3668 unsigned int from,
3669 unsigned int to,
3670 bfd_boolean phdr)
252b5132
RH
3671{
3672 struct elf_segment_map *m;
3673 unsigned int i;
3674 asection **hdrpp;
dc810e39 3675 bfd_size_type amt;
252b5132 3676
dc810e39
AM
3677 amt = sizeof (struct elf_segment_map);
3678 amt += (to - from - 1) * sizeof (asection *);
a50b1753 3679 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
252b5132
RH
3680 if (m == NULL)
3681 return NULL;
3682 m->next = NULL;
3683 m->p_type = PT_LOAD;
3684 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3685 m->sections[i - from] = *hdrpp;
3686 m->count = to - from;
3687
3688 if (from == 0 && phdr)
3689 {
3690 /* Include the headers in the first PT_LOAD segment. */
3691 m->includes_filehdr = 1;
3692 m->includes_phdrs = 1;
3693 }
3694
3695 return m;
3696}
3697
229fcec5
MM
3698/* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3699 on failure. */
3700
3701struct elf_segment_map *
3702_bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3703{
3704 struct elf_segment_map *m;
3705
a50b1753
NC
3706 m = (struct elf_segment_map *) bfd_zalloc (abfd,
3707 sizeof (struct elf_segment_map));
229fcec5
MM
3708 if (m == NULL)
3709 return NULL;
3710 m->next = NULL;
3711 m->p_type = PT_DYNAMIC;
3712 m->count = 1;
3713 m->sections[0] = dynsec;
08a40648 3714
229fcec5
MM
3715 return m;
3716}
3717
8ded5a0f 3718/* Possibly add or remove segments from the segment map. */
252b5132 3719
b34976b6 3720static bfd_boolean
3dea8fca
AM
3721elf_modify_segment_map (bfd *abfd,
3722 struct bfd_link_info *info,
3723 bfd_boolean remove_empty_load)
252b5132 3724{
252e386e 3725 struct elf_segment_map **m;
8ded5a0f 3726 const struct elf_backend_data *bed;
252b5132 3727
8ded5a0f
AM
3728 /* The placement algorithm assumes that non allocated sections are
3729 not in PT_LOAD segments. We ensure this here by removing such
3730 sections from the segment map. We also remove excluded
252e386e
AM
3731 sections. Finally, any PT_LOAD segment without sections is
3732 removed. */
12bd6957 3733 m = &elf_seg_map (abfd);
252e386e 3734 while (*m)
8ded5a0f
AM
3735 {
3736 unsigned int i, new_count;
252b5132 3737
252e386e 3738 for (new_count = 0, i = 0; i < (*m)->count; i++)
8ded5a0f 3739 {
252e386e
AM
3740 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3741 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3742 || (*m)->p_type != PT_LOAD))
8ded5a0f 3743 {
252e386e
AM
3744 (*m)->sections[new_count] = (*m)->sections[i];
3745 new_count++;
8ded5a0f
AM
3746 }
3747 }
252e386e 3748 (*m)->count = new_count;
252b5132 3749
3dea8fca 3750 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
252e386e
AM
3751 *m = (*m)->next;
3752 else
3753 m = &(*m)->next;
8ded5a0f 3754 }
252b5132 3755
8ded5a0f
AM
3756 bed = get_elf_backend_data (abfd);
3757 if (bed->elf_backend_modify_segment_map != NULL)
252b5132 3758 {
252e386e 3759 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
8ded5a0f 3760 return FALSE;
252b5132 3761 }
252b5132 3762
8ded5a0f
AM
3763 return TRUE;
3764}
252b5132 3765
8ded5a0f 3766/* Set up a mapping from BFD sections to program segments. */
252b5132 3767
8ded5a0f
AM
3768bfd_boolean
3769_bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3770{
3771 unsigned int count;
3772 struct elf_segment_map *m;
3773 asection **sections = NULL;
3774 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3dea8fca 3775 bfd_boolean no_user_phdrs;
252b5132 3776
12bd6957 3777 no_user_phdrs = elf_seg_map (abfd) == NULL;
d324f6d6
RM
3778
3779 if (info != NULL)
3780 info->user_phdrs = !no_user_phdrs;
3781
3dea8fca 3782 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
252b5132 3783 {
8ded5a0f
AM
3784 asection *s;
3785 unsigned int i;
3786 struct elf_segment_map *mfirst;
3787 struct elf_segment_map **pm;
3788 asection *last_hdr;
3789 bfd_vma last_size;
3790 unsigned int phdr_index;
3791 bfd_vma maxpagesize;
3792 asection **hdrpp;
3793 bfd_boolean phdr_in_segment = TRUE;
3794 bfd_boolean writable;
3795 int tls_count = 0;
3796 asection *first_tls = NULL;
3797 asection *dynsec, *eh_frame_hdr;
3798 bfd_size_type amt;
8d06853e 3799 bfd_vma addr_mask, wrap_to = 0;
252b5132 3800
8ded5a0f 3801 /* Select the allocated sections, and sort them. */
252b5132 3802
a50b1753
NC
3803 sections = (asection **) bfd_malloc2 (bfd_count_sections (abfd),
3804 sizeof (asection *));
8ded5a0f 3805 if (sections == NULL)
252b5132 3806 goto error_return;
252b5132 3807
8d06853e
AM
3808 /* Calculate top address, avoiding undefined behaviour of shift
3809 left operator when shift count is equal to size of type
3810 being shifted. */
3811 addr_mask = ((bfd_vma) 1 << (bfd_arch_bits_per_address (abfd) - 1)) - 1;
3812 addr_mask = (addr_mask << 1) + 1;
3813
8ded5a0f
AM
3814 i = 0;
3815 for (s = abfd->sections; s != NULL; s = s->next)
3816 {
3817 if ((s->flags & SEC_ALLOC) != 0)
3818 {
3819 sections[i] = s;
3820 ++i;
8d06853e
AM
3821 /* A wrapping section potentially clashes with header. */
3822 if (((s->lma + s->size) & addr_mask) < (s->lma & addr_mask))
3823 wrap_to = (s->lma + s->size) & addr_mask;
8ded5a0f
AM
3824 }
3825 }
3826 BFD_ASSERT (i <= bfd_count_sections (abfd));
3827 count = i;
252b5132 3828
8ded5a0f 3829 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
252b5132 3830
8ded5a0f 3831 /* Build the mapping. */
252b5132 3832
8ded5a0f
AM
3833 mfirst = NULL;
3834 pm = &mfirst;
252b5132 3835
8ded5a0f
AM
3836 /* If we have a .interp section, then create a PT_PHDR segment for
3837 the program headers and a PT_INTERP segment for the .interp
3838 section. */
3839 s = bfd_get_section_by_name (abfd, ".interp");
3840 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3841 {
3842 amt = sizeof (struct elf_segment_map);
a50b1753 3843 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM
3844 if (m == NULL)
3845 goto error_return;
3846 m->next = NULL;
3847 m->p_type = PT_PHDR;
3848 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3849 m->p_flags = PF_R | PF_X;
3850 m->p_flags_valid = 1;
3851 m->includes_phdrs = 1;
252b5132 3852
8ded5a0f
AM
3853 *pm = m;
3854 pm = &m->next;
252b5132 3855
8ded5a0f 3856 amt = sizeof (struct elf_segment_map);
a50b1753 3857 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM
3858 if (m == NULL)
3859 goto error_return;
3860 m->next = NULL;
3861 m->p_type = PT_INTERP;
3862 m->count = 1;
3863 m->sections[0] = s;
3864
3865 *pm = m;
3866 pm = &m->next;
252b5132 3867 }
8ded5a0f
AM
3868
3869 /* Look through the sections. We put sections in the same program
3870 segment when the start of the second section can be placed within
3871 a few bytes of the end of the first section. */
3872 last_hdr = NULL;
3873 last_size = 0;
3874 phdr_index = 0;
3875 maxpagesize = bed->maxpagesize;
3876 writable = FALSE;
3877 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3878 if (dynsec != NULL
3879 && (dynsec->flags & SEC_LOAD) == 0)
3880 dynsec = NULL;
3881
3882 /* Deal with -Ttext or something similar such that the first section
3883 is not adjacent to the program headers. This is an
3884 approximation, since at this point we don't know exactly how many
3885 program headers we will need. */
3886 if (count > 0)
252b5132 3887 {
12bd6957 3888 bfd_size_type phdr_size = elf_program_header_size (abfd);
8ded5a0f 3889
62d7a5f6 3890 if (phdr_size == (bfd_size_type) -1)
8ded5a0f 3891 phdr_size = get_program_header_size (abfd, info);
d2bcb0d1 3892 phdr_size += bed->s->sizeof_ehdr;
8ded5a0f 3893 if ((abfd->flags & D_PAGED) == 0
8d06853e
AM
3894 || (sections[0]->lma & addr_mask) < phdr_size
3895 || ((sections[0]->lma & addr_mask) % maxpagesize
3896 < phdr_size % maxpagesize)
3897 || (sections[0]->lma & addr_mask & -maxpagesize) < wrap_to)
8ded5a0f 3898 phdr_in_segment = FALSE;
252b5132
RH
3899 }
3900
8ded5a0f 3901 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
252b5132 3902 {
8ded5a0f
AM
3903 asection *hdr;
3904 bfd_boolean new_segment;
3905
3906 hdr = *hdrpp;
3907
3908 /* See if this section and the last one will fit in the same
3909 segment. */
3910
3911 if (last_hdr == NULL)
3912 {
3913 /* If we don't have a segment yet, then we don't need a new
3914 one (we build the last one after this loop). */
3915 new_segment = FALSE;
3916 }
3917 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3918 {
3919 /* If this section has a different relation between the
3920 virtual address and the load address, then we need a new
3921 segment. */
3922 new_segment = TRUE;
3923 }
b5599592
AM
3924 else if (hdr->lma < last_hdr->lma + last_size
3925 || last_hdr->lma + last_size < last_hdr->lma)
3926 {
3927 /* If this section has a load address that makes it overlap
3928 the previous section, then we need a new segment. */
3929 new_segment = TRUE;
3930 }
39948a60
NC
3931 /* In the next test we have to be careful when last_hdr->lma is close
3932 to the end of the address space. If the aligned address wraps
3933 around to the start of the address space, then there are no more
3934 pages left in memory and it is OK to assume that the current
3935 section can be included in the current segment. */
3936 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3937 > last_hdr->lma)
3938 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
4ff73856 3939 <= hdr->lma))
8ded5a0f
AM
3940 {
3941 /* If putting this section in this segment would force us to
3942 skip a page in the segment, then we need a new segment. */
3943 new_segment = TRUE;
3944 }
3945 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3946 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3947 {
3948 /* We don't want to put a loadable section after a
3949 nonloadable section in the same segment.
3950 Consider .tbss sections as loadable for this purpose. */
3951 new_segment = TRUE;
3952 }
3953 else if ((abfd->flags & D_PAGED) == 0)
3954 {
3955 /* If the file is not demand paged, which means that we
3956 don't require the sections to be correctly aligned in the
3957 file, then there is no other reason for a new segment. */
3958 new_segment = FALSE;
3959 }
3960 else if (! writable
3961 && (hdr->flags & SEC_READONLY) == 0
8d06853e
AM
3962 && (((last_hdr->lma + last_size - 1) & -maxpagesize)
3963 != (hdr->lma & -maxpagesize)))
8ded5a0f
AM
3964 {
3965 /* We don't want to put a writable section in a read only
3966 segment, unless they are on the same page in memory
3967 anyhow. We already know that the last section does not
3968 bring us past the current section on the page, so the
3969 only case in which the new section is not on the same
3970 page as the previous section is when the previous section
3971 ends precisely on a page boundary. */
3972 new_segment = TRUE;
3973 }
3974 else
3975 {
3976 /* Otherwise, we can use the same segment. */
3977 new_segment = FALSE;
3978 }
3979
2889e75b 3980 /* Allow interested parties a chance to override our decision. */
ceae84aa
AM
3981 if (last_hdr != NULL
3982 && info != NULL
3983 && info->callbacks->override_segment_assignment != NULL)
3984 new_segment
3985 = info->callbacks->override_segment_assignment (info, abfd, hdr,
3986 last_hdr,
3987 new_segment);
2889e75b 3988
8ded5a0f
AM
3989 if (! new_segment)
3990 {
3991 if ((hdr->flags & SEC_READONLY) == 0)
3992 writable = TRUE;
3993 last_hdr = hdr;
3994 /* .tbss sections effectively have zero size. */
3995 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3996 != SEC_THREAD_LOCAL)
3997 last_size = hdr->size;
3998 else
3999 last_size = 0;
4000 continue;
4001 }
4002
4003 /* We need a new program segment. We must create a new program
4004 header holding all the sections from phdr_index until hdr. */
4005
4006 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4007 if (m == NULL)
4008 goto error_return;
4009
4010 *pm = m;
4011 pm = &m->next;
4012
252b5132 4013 if ((hdr->flags & SEC_READONLY) == 0)
b34976b6 4014 writable = TRUE;
8ded5a0f
AM
4015 else
4016 writable = FALSE;
4017
baaff79e
JJ
4018 last_hdr = hdr;
4019 /* .tbss sections effectively have zero size. */
e5caec89 4020 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
eea6121a 4021 last_size = hdr->size;
baaff79e
JJ
4022 else
4023 last_size = 0;
8ded5a0f
AM
4024 phdr_index = i;
4025 phdr_in_segment = FALSE;
252b5132
RH
4026 }
4027
86b2281f
AM
4028 /* Create a final PT_LOAD program segment, but not if it's just
4029 for .tbss. */
4030 if (last_hdr != NULL
4031 && (i - phdr_index != 1
4032 || ((last_hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
4033 != SEC_THREAD_LOCAL)))
8ded5a0f
AM
4034 {
4035 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
4036 if (m == NULL)
4037 goto error_return;
252b5132 4038
8ded5a0f
AM
4039 *pm = m;
4040 pm = &m->next;
4041 }
252b5132 4042
8ded5a0f
AM
4043 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
4044 if (dynsec != NULL)
4045 {
4046 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
4047 if (m == NULL)
4048 goto error_return;
4049 *pm = m;
4050 pm = &m->next;
4051 }
252b5132 4052
1c5265b5
JJ
4053 /* For each batch of consecutive loadable .note sections,
4054 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
4055 because if we link together nonloadable .note sections and
4056 loadable .note sections, we will generate two .note sections
4057 in the output file. FIXME: Using names for section types is
4058 bogus anyhow. */
8ded5a0f
AM
4059 for (s = abfd->sections; s != NULL; s = s->next)
4060 {
4061 if ((s->flags & SEC_LOAD) != 0
0112cd26 4062 && CONST_STRNEQ (s->name, ".note"))
8ded5a0f 4063 {
1c5265b5 4064 asection *s2;
91d6fa6a
NC
4065
4066 count = 1;
8ded5a0f 4067 amt = sizeof (struct elf_segment_map);
1c5265b5
JJ
4068 if (s->alignment_power == 2)
4069 for (s2 = s; s2->next != NULL; s2 = s2->next)
55b581a6
JJ
4070 {
4071 if (s2->next->alignment_power == 2
4072 && (s2->next->flags & SEC_LOAD) != 0
4073 && CONST_STRNEQ (s2->next->name, ".note")
8d06853e
AM
4074 && align_power (s2->lma + s2->size, 2)
4075 == s2->next->lma)
55b581a6
JJ
4076 count++;
4077 else
4078 break;
4079 }
1c5265b5 4080 amt += (count - 1) * sizeof (asection *);
a50b1753 4081 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM
4082 if (m == NULL)
4083 goto error_return;
4084 m->next = NULL;
4085 m->p_type = PT_NOTE;
1c5265b5
JJ
4086 m->count = count;
4087 while (count > 1)
4088 {
4089 m->sections[m->count - count--] = s;
4090 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
4091 s = s->next;
4092 }
4093 m->sections[m->count - 1] = s;
4094 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
8ded5a0f
AM
4095 *pm = m;
4096 pm = &m->next;
4097 }
4098 if (s->flags & SEC_THREAD_LOCAL)
4099 {
4100 if (! tls_count)
4101 first_tls = s;
4102 tls_count++;
4103 }
4104 }
252b5132 4105
8ded5a0f
AM
4106 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
4107 if (tls_count > 0)
4108 {
8ded5a0f
AM
4109 amt = sizeof (struct elf_segment_map);
4110 amt += (tls_count - 1) * sizeof (asection *);
a50b1753 4111 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM
4112 if (m == NULL)
4113 goto error_return;
4114 m->next = NULL;
4115 m->p_type = PT_TLS;
4116 m->count = tls_count;
4117 /* Mandated PF_R. */
4118 m->p_flags = PF_R;
4119 m->p_flags_valid = 1;
d923cae0 4120 s = first_tls;
91d6fa6a 4121 for (i = 0; i < (unsigned int) tls_count; ++i)
8ded5a0f 4122 {
d923cae0
L
4123 if ((s->flags & SEC_THREAD_LOCAL) == 0)
4124 {
4125 _bfd_error_handler
4126 (_("%B: TLS sections are not adjacent:"), abfd);
4127 s = first_tls;
4128 i = 0;
4129 while (i < (unsigned int) tls_count)
4130 {
4131 if ((s->flags & SEC_THREAD_LOCAL) != 0)
4132 {
4133 _bfd_error_handler (_(" TLS: %A"), s);
4134 i++;
4135 }
4136 else
4137 _bfd_error_handler (_(" non-TLS: %A"), s);
4138 s = s->next;
4139 }
4140 bfd_set_error (bfd_error_bad_value);
4141 goto error_return;
4142 }
4143 m->sections[i] = s;
4144 s = s->next;
8ded5a0f 4145 }
252b5132 4146
8ded5a0f
AM
4147 *pm = m;
4148 pm = &m->next;
4149 }
252b5132 4150
8ded5a0f
AM
4151 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
4152 segment. */
12bd6957 4153 eh_frame_hdr = elf_eh_frame_hdr (abfd);
8ded5a0f
AM
4154 if (eh_frame_hdr != NULL
4155 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
252b5132 4156 {
dc810e39 4157 amt = sizeof (struct elf_segment_map);
a50b1753 4158 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
252b5132
RH
4159 if (m == NULL)
4160 goto error_return;
4161 m->next = NULL;
8ded5a0f 4162 m->p_type = PT_GNU_EH_FRAME;
252b5132 4163 m->count = 1;
8ded5a0f 4164 m->sections[0] = eh_frame_hdr->output_section;
252b5132
RH
4165
4166 *pm = m;
4167 pm = &m->next;
4168 }
13ae64f3 4169
12bd6957 4170 if (elf_stack_flags (abfd))
13ae64f3 4171 {
8ded5a0f 4172 amt = sizeof (struct elf_segment_map);
a50b1753 4173 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
8ded5a0f
AM
4174 if (m == NULL)
4175 goto error_return;
4176 m->next = NULL;
2b05f1b7 4177 m->p_type = PT_GNU_STACK;
12bd6957 4178 m->p_flags = elf_stack_flags (abfd);
04c3a755 4179 m->p_align = bed->stack_align;
8ded5a0f 4180 m->p_flags_valid = 1;
04c3a755
NS
4181 m->p_align_valid = m->p_align != 0;
4182 if (info->stacksize > 0)
4183 {
4184 m->p_size = info->stacksize;
4185 m->p_size_valid = 1;
4186 }
252b5132 4187
8ded5a0f
AM
4188 *pm = m;
4189 pm = &m->next;
4190 }
65765700 4191
ceae84aa 4192 if (info != NULL && info->relro)
8ded5a0f 4193 {
f210dcff
L
4194 for (m = mfirst; m != NULL; m = m->next)
4195 {
3832a4d8
AM
4196 if (m->p_type == PT_LOAD
4197 && m->count != 0
4198 && m->sections[0]->vma >= info->relro_start
4199 && m->sections[0]->vma < info->relro_end)
f210dcff 4200 {
3832a4d8
AM
4201 i = m->count;
4202 while (--i != (unsigned) -1)
4203 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS))
4204 == (SEC_LOAD | SEC_HAS_CONTENTS))
4205 break;
4206
43a8475c 4207 if (i != (unsigned) -1)
f210dcff
L
4208 break;
4209 }
be01b344 4210 }
f210dcff
L
4211
4212 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
4213 if (m != NULL)
4214 {
4215 amt = sizeof (struct elf_segment_map);
a50b1753 4216 m = (struct elf_segment_map *) bfd_zalloc (abfd, amt);
f210dcff
L
4217 if (m == NULL)
4218 goto error_return;
4219 m->next = NULL;
4220 m->p_type = PT_GNU_RELRO;
4221 m->p_flags = PF_R;
4222 m->p_flags_valid = 1;
4223
4224 *pm = m;
4225 pm = &m->next;
4226 }
8ded5a0f 4227 }
9ee5e499 4228
8ded5a0f 4229 free (sections);
12bd6957 4230 elf_seg_map (abfd) = mfirst;
9ee5e499
JJ
4231 }
4232
3dea8fca 4233 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
8ded5a0f 4234 return FALSE;
8c37241b 4235
12bd6957 4236 for (count = 0, m = elf_seg_map (abfd); m != NULL; m = m->next)
8ded5a0f 4237 ++count;
12bd6957 4238 elf_program_header_size (abfd) = count * bed->s->sizeof_phdr;
252b5132 4239
b34976b6 4240 return TRUE;
252b5132
RH
4241
4242 error_return:
4243 if (sections != NULL)
4244 free (sections);
b34976b6 4245 return FALSE;
252b5132
RH
4246}
4247
4248/* Sort sections by address. */
4249
4250static int
217aa764 4251elf_sort_sections (const void *arg1, const void *arg2)
252b5132
RH
4252{
4253 const asection *sec1 = *(const asection **) arg1;
4254 const asection *sec2 = *(const asection **) arg2;
eecdbe52 4255 bfd_size_type size1, size2;
252b5132
RH
4256
4257 /* Sort by LMA first, since this is the address used to
4258 place the section into a segment. */
4259 if (sec1->lma < sec2->lma)
4260 return -1;
4261 else if (sec1->lma > sec2->lma)
4262 return 1;
4263
4264 /* Then sort by VMA. Normally the LMA and the VMA will be
4265 the same, and this will do nothing. */
4266 if (sec1->vma < sec2->vma)
4267 return -1;
4268 else if (sec1->vma > sec2->vma)
4269 return 1;
4270
4271 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4272
07c6e936 4273#define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
252b5132
RH
4274
4275 if (TOEND (sec1))
4276 {
4277 if (TOEND (sec2))
00a7cdc5
NC
4278 {
4279 /* If the indicies are the same, do not return 0
4280 here, but continue to try the next comparison. */
4281 if (sec1->target_index - sec2->target_index != 0)
4282 return sec1->target_index - sec2->target_index;
4283 }
252b5132
RH
4284 else
4285 return 1;
4286 }
00a7cdc5 4287 else if (TOEND (sec2))
252b5132
RH
4288 return -1;
4289
4290#undef TOEND
4291
00a7cdc5
NC
4292 /* Sort by size, to put zero sized sections
4293 before others at the same address. */
252b5132 4294
eea6121a
AM
4295 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4296 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
eecdbe52
JJ
4297
4298 if (size1 < size2)
252b5132 4299 return -1;
eecdbe52 4300 if (size1 > size2)
252b5132
RH
4301 return 1;
4302
4303 return sec1->target_index - sec2->target_index;
4304}
4305
340b6d91
AC
4306/* Ian Lance Taylor writes:
4307
4308 We shouldn't be using % with a negative signed number. That's just
4309 not good. We have to make sure either that the number is not
4310 negative, or that the number has an unsigned type. When the types
4311 are all the same size they wind up as unsigned. When file_ptr is a
4312 larger signed type, the arithmetic winds up as signed long long,
4313 which is wrong.
4314
4315 What we're trying to say here is something like ``increase OFF by
4316 the least amount that will cause it to be equal to the VMA modulo
4317 the page size.'' */
4318/* In other words, something like:
4319
4320 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4321 off_offset = off % bed->maxpagesize;
4322 if (vma_offset < off_offset)
4323 adjustment = vma_offset + bed->maxpagesize - off_offset;
4324 else
4325 adjustment = vma_offset - off_offset;
08a40648 4326
340b6d91
AC
4327 which can can be collapsed into the expression below. */
4328
4329static file_ptr
4330vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4331{
dc9155b2
NC
4332 /* PR binutils/16199: Handle an alignment of zero. */
4333 if (maxpagesize == 0)
4334 maxpagesize = 1;
340b6d91
AC
4335 return ((vma - off) % maxpagesize);
4336}
4337
6d33f217
L
4338static void
4339print_segment_map (const struct elf_segment_map *m)
4340{
4341 unsigned int j;
4342 const char *pt = get_segment_type (m->p_type);
4343 char buf[32];
4344
4345 if (pt == NULL)
4346 {
4347 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4348 sprintf (buf, "LOPROC+%7.7x",
4349 (unsigned int) (m->p_type - PT_LOPROC));
4350 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4351 sprintf (buf, "LOOS+%7.7x",
4352 (unsigned int) (m->p_type - PT_LOOS));
4353 else
4354 snprintf (buf, sizeof (buf), "%8.8x",
4355 (unsigned int) m->p_type);
4356 pt = buf;
4357 }
4a97a0e5 4358 fflush (stdout);
6d33f217
L
4359 fprintf (stderr, "%s:", pt);
4360 for (j = 0; j < m->count; j++)
4361 fprintf (stderr, " %s", m->sections [j]->name);
4362 putc ('\n',stderr);
4a97a0e5 4363 fflush (stderr);
6d33f217
L
4364}
4365
32812159
AM
4366static bfd_boolean
4367write_zeros (bfd *abfd, file_ptr pos, bfd_size_type len)
4368{
4369 void *buf;
4370 bfd_boolean ret;
4371
4372 if (bfd_seek (abfd, pos, SEEK_SET) != 0)
4373 return FALSE;
4374 buf = bfd_zmalloc (len);
4375 if (buf == NULL)
4376 return FALSE;
4377 ret = bfd_bwrite (buf, len, abfd) == len;
4378 free (buf);
4379 return ret;
4380}
4381
252b5132
RH
4382/* Assign file positions to the sections based on the mapping from
4383 sections to segments. This function also sets up some fields in
f3520d2f 4384 the file header. */
252b5132 4385
b34976b6 4386static bfd_boolean
f3520d2f
AM
4387assign_file_positions_for_load_sections (bfd *abfd,
4388 struct bfd_link_info *link_info)
252b5132
RH
4389{
4390 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 4391 struct elf_segment_map *m;
252b5132 4392 Elf_Internal_Phdr *phdrs;
252b5132 4393 Elf_Internal_Phdr *p;
02bf8d82 4394 file_ptr off;
3f570048 4395 bfd_size_type maxpagesize;
f3520d2f 4396 unsigned int alloc;
0920dee7 4397 unsigned int i, j;
2b0bc088 4398 bfd_vma header_pad = 0;
252b5132 4399
e36284ab 4400 if (link_info == NULL
ceae84aa 4401 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
8ded5a0f 4402 return FALSE;
252b5132 4403
8ded5a0f 4404 alloc = 0;
12bd6957 4405 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
2b0bc088
NC
4406 {
4407 ++alloc;
4408 if (m->header_size)
4409 header_pad = m->header_size;
4410 }
252b5132 4411
82f2dbf7
NC
4412 if (alloc)
4413 {
4414 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4415 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
4416 }
4417 else
4418 {
4419 /* PR binutils/12467. */
4420 elf_elfheader (abfd)->e_phoff = 0;
4421 elf_elfheader (abfd)->e_phentsize = 0;
4422 }
d324f6d6 4423
8ded5a0f 4424 elf_elfheader (abfd)->e_phnum = alloc;
252b5132 4425
12bd6957
AM
4426 if (elf_program_header_size (abfd) == (bfd_size_type) -1)
4427 elf_program_header_size (abfd) = alloc * bed->s->sizeof_phdr;
8ded5a0f 4428 else
12bd6957 4429 BFD_ASSERT (elf_program_header_size (abfd)
59e0647f 4430 >= alloc * bed->s->sizeof_phdr);
252b5132
RH
4431
4432 if (alloc == 0)
f3520d2f 4433 {
12bd6957 4434 elf_next_file_pos (abfd) = bed->s->sizeof_ehdr;
8ded5a0f 4435 return TRUE;
f3520d2f 4436 }
252b5132 4437
12bd6957 4438 /* We're writing the size in elf_program_header_size (abfd),
57268894
HPN
4439 see assign_file_positions_except_relocs, so make sure we have
4440 that amount allocated, with trailing space cleared.
12bd6957
AM
4441 The variable alloc contains the computed need, while
4442 elf_program_header_size (abfd) contains the size used for the
57268894
HPN
4443 layout.
4444 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4445 where the layout is forced to according to a larger size in the
4446 last iterations for the testcase ld-elf/header. */
12bd6957 4447 BFD_ASSERT (elf_program_header_size (abfd) % bed->s->sizeof_phdr
57268894 4448 == 0);
a50b1753
NC
4449 phdrs = (Elf_Internal_Phdr *)
4450 bfd_zalloc2 (abfd,
12bd6957 4451 (elf_program_header_size (abfd) / bed->s->sizeof_phdr),
a50b1753 4452 sizeof (Elf_Internal_Phdr));
f3520d2f 4453 elf_tdata (abfd)->phdr = phdrs;
252b5132 4454 if (phdrs == NULL)
b34976b6 4455 return FALSE;
252b5132 4456
3f570048
AM
4457 maxpagesize = 1;
4458 if ((abfd->flags & D_PAGED) != 0)
4459 maxpagesize = bed->maxpagesize;
4460
252b5132
RH
4461 off = bed->s->sizeof_ehdr;
4462 off += alloc * bed->s->sizeof_phdr;
2b0bc088
NC
4463 if (header_pad < (bfd_vma) off)
4464 header_pad = 0;
4465 else
4466 header_pad -= off;
4467 off += header_pad;
252b5132 4468
12bd6957 4469 for (m = elf_seg_map (abfd), p = phdrs, j = 0;
252b5132 4470 m != NULL;
0920dee7 4471 m = m->next, p++, j++)
252b5132 4472 {
252b5132 4473 asection **secpp;
bf988460
AM
4474 bfd_vma off_adjust;
4475 bfd_boolean no_contents;
252b5132
RH
4476
4477 /* If elf_segment_map is not from map_sections_to_segments, the
08a40648 4478 sections may not be correctly ordered. NOTE: sorting should
52e9b619
MS
4479 not be done to the PT_NOTE section of a corefile, which may
4480 contain several pseudo-sections artificially created by bfd.
4481 Sorting these pseudo-sections breaks things badly. */
47d9a591
AM
4482 if (m->count > 1
4483 && !(elf_elfheader (abfd)->e_type == ET_CORE
52e9b619 4484 && m->p_type == PT_NOTE))
252b5132
RH
4485 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4486 elf_sort_sections);
4487
b301b248
AM
4488 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4489 number of sections with contents contributing to both p_filesz
4490 and p_memsz, followed by a number of sections with no contents
4491 that just contribute to p_memsz. In this loop, OFF tracks next
02bf8d82 4492 available file offset for PT_LOAD and PT_NOTE segments. */
252b5132 4493 p->p_type = m->p_type;
28a7f3e7 4494 p->p_flags = m->p_flags;
252b5132 4495
3f570048
AM
4496 if (m->count == 0)
4497 p->p_vaddr = 0;
4498 else
3271a814 4499 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
3f570048
AM
4500
4501 if (m->p_paddr_valid)
4502 p->p_paddr = m->p_paddr;
4503 else if (m->count == 0)
4504 p->p_paddr = 0;
4505 else
08a40648 4506 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
3f570048
AM
4507
4508 if (p->p_type == PT_LOAD
4509 && (abfd->flags & D_PAGED) != 0)
4510 {
4511 /* p_align in demand paged PT_LOAD segments effectively stores
4512 the maximum page size. When copying an executable with
4513 objcopy, we set m->p_align from the input file. Use this
4514 value for maxpagesize rather than bed->maxpagesize, which
4515 may be different. Note that we use maxpagesize for PT_TLS
4516 segment alignment later in this function, so we are relying
4517 on at least one PT_LOAD segment appearing before a PT_TLS
4518 segment. */
4519 if (m->p_align_valid)
4520 maxpagesize = m->p_align;
4521
4522 p->p_align = maxpagesize;
4523 }
3271a814
NS
4524 else if (m->p_align_valid)
4525 p->p_align = m->p_align;
e970b90a
DJ
4526 else if (m->count == 0)
4527 p->p_align = 1 << bed->s->log_file_align;
3f570048
AM
4528 else
4529 p->p_align = 0;
4530
bf988460
AM
4531 no_contents = FALSE;
4532 off_adjust = 0;
252b5132 4533 if (p->p_type == PT_LOAD
b301b248 4534 && m->count > 0)
252b5132 4535 {
b301b248 4536 bfd_size_type align;
a49e53ed 4537 unsigned int align_power = 0;
b301b248 4538
3271a814
NS
4539 if (m->p_align_valid)
4540 align = p->p_align;
4541 else
252b5132 4542 {
3271a814
NS
4543 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4544 {
4545 unsigned int secalign;
08a40648 4546
3271a814
NS
4547 secalign = bfd_get_section_alignment (abfd, *secpp);
4548 if (secalign > align_power)
4549 align_power = secalign;
4550 }
4551 align = (bfd_size_type) 1 << align_power;
4552 if (align < maxpagesize)
4553 align = maxpagesize;
b301b248 4554 }
252b5132 4555
02bf8d82
AM
4556 for (i = 0; i < m->count; i++)
4557 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4558 /* If we aren't making room for this section, then
4559 it must be SHT_NOBITS regardless of what we've
4560 set via struct bfd_elf_special_section. */
4561 elf_section_type (m->sections[i]) = SHT_NOBITS;
4562
bf988460 4563 /* Find out whether this segment contains any loadable
aea274d3
AM
4564 sections. */
4565 no_contents = TRUE;
4566 for (i = 0; i < m->count; i++)
4567 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4568 {
4569 no_contents = FALSE;
4570 break;
4571 }
bf988460 4572
85cfcbfb 4573 off_adjust = vma_page_aligned_bias (p->p_vaddr, off, align);
bf988460
AM
4574 off += off_adjust;
4575 if (no_contents)
4576 {
4577 /* We shouldn't need to align the segment on disk since
4578 the segment doesn't need file space, but the gABI
4579 arguably requires the alignment and glibc ld.so
4580 checks it. So to comply with the alignment
4581 requirement but not waste file space, we adjust
4582 p_offset for just this segment. (OFF_ADJUST is
4583 subtracted from OFF later.) This may put p_offset
4584 past the end of file, but that shouldn't matter. */
4585 }
4586 else
4587 off_adjust = 0;
252b5132 4588 }
b1a6d0b1
NC
4589 /* Make sure the .dynamic section is the first section in the
4590 PT_DYNAMIC segment. */
4591 else if (p->p_type == PT_DYNAMIC
4592 && m->count > 1
4593 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4594 {
4595 _bfd_error_handler
b301b248
AM
4596 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4597 abfd);
b1a6d0b1
NC
4598 bfd_set_error (bfd_error_bad_value);
4599 return FALSE;
4600 }
3f001e84
JK
4601 /* Set the note section type to SHT_NOTE. */
4602 else if (p->p_type == PT_NOTE)
4603 for (i = 0; i < m->count; i++)
4604 elf_section_type (m->sections[i]) = SHT_NOTE;
252b5132 4605
252b5132
RH
4606 p->p_offset = 0;
4607 p->p_filesz = 0;
4608 p->p_memsz = 0;
4609
4610 if (m->includes_filehdr)
4611 {
bf988460 4612 if (!m->p_flags_valid)
252b5132 4613 p->p_flags |= PF_R;
252b5132
RH
4614 p->p_filesz = bed->s->sizeof_ehdr;
4615 p->p_memsz = bed->s->sizeof_ehdr;
4616 if (m->count > 0)
4617 {
252b5132
RH
4618 if (p->p_vaddr < (bfd_vma) off)
4619 {
caf47ea6 4620 (*_bfd_error_handler)
b301b248
AM
4621 (_("%B: Not enough room for program headers, try linking with -N"),
4622 abfd);
252b5132 4623 bfd_set_error (bfd_error_bad_value);
b34976b6 4624 return FALSE;
252b5132
RH
4625 }
4626
4627 p->p_vaddr -= off;
bf988460 4628 if (!m->p_paddr_valid)
252b5132
RH
4629 p->p_paddr -= off;
4630 }
252b5132
RH
4631 }
4632
4633 if (m->includes_phdrs)
4634 {
bf988460 4635 if (!m->p_flags_valid)
252b5132
RH
4636 p->p_flags |= PF_R;
4637
f3520d2f 4638 if (!m->includes_filehdr)
252b5132
RH
4639 {
4640 p->p_offset = bed->s->sizeof_ehdr;
4641
4642 if (m->count > 0)
4643 {
252b5132 4644 p->p_vaddr -= off - p->p_offset;
bf988460 4645 if (!m->p_paddr_valid)
252b5132
RH
4646 p->p_paddr -= off - p->p_offset;
4647 }
252b5132
RH
4648 }
4649
4650 p->p_filesz += alloc * bed->s->sizeof_phdr;
4651 p->p_memsz += alloc * bed->s->sizeof_phdr;
2b0bc088
NC
4652 if (m->count)
4653 {
4654 p->p_filesz += header_pad;
4655 p->p_memsz += header_pad;
4656 }
252b5132
RH
4657 }
4658
4659 if (p->p_type == PT_LOAD
4660 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4661 {
bf988460 4662 if (!m->includes_filehdr && !m->includes_phdrs)
02bf8d82 4663 p->p_offset = off;
252b5132
RH
4664 else
4665 {
4666 file_ptr adjust;
4667
4668 adjust = off - (p->p_offset + p->p_filesz);
bf988460
AM
4669 if (!no_contents)
4670 p->p_filesz += adjust;
252b5132
RH
4671 p->p_memsz += adjust;
4672 }
4673 }
4674
1ea63fd2
AM
4675 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4676 maps. Set filepos for sections in PT_LOAD segments, and in
4677 core files, for sections in PT_NOTE segments.
4678 assign_file_positions_for_non_load_sections will set filepos
4679 for other sections and update p_filesz for other segments. */
252b5132
RH
4680 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4681 {
4682 asection *sec;
252b5132 4683 bfd_size_type align;
627b32bc 4684 Elf_Internal_Shdr *this_hdr;
252b5132
RH
4685
4686 sec = *secpp;
02bf8d82 4687 this_hdr = &elf_section_data (sec)->this_hdr;
3f570048 4688 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
252b5132 4689
88967714
AM
4690 if ((p->p_type == PT_LOAD
4691 || p->p_type == PT_TLS)
4692 && (this_hdr->sh_type != SHT_NOBITS
4693 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4694 && ((this_hdr->sh_flags & SHF_TLS) == 0
4695 || p->p_type == PT_TLS))))
252b5132 4696 {
b5599592
AM
4697 bfd_vma p_start = p->p_paddr;
4698 bfd_vma p_end = p_start + p->p_memsz;
4699 bfd_vma s_start = sec->lma;
4700 bfd_vma adjust = s_start - p_end;
252b5132 4701
a2d1e028
L
4702 if (adjust != 0
4703 && (s_start < p_end
4704 || p_end < p_start))
252b5132 4705 {
88967714 4706 (*_bfd_error_handler)
b5599592
AM
4707 (_("%B: section %A lma %#lx adjusted to %#lx"), abfd, sec,
4708 (unsigned long) s_start, (unsigned long) p_end);
88967714 4709 adjust = 0;
b5599592 4710 sec->lma = p_end;
1cfb7d1e 4711 }
3ac9b6c9 4712 p->p_memsz += adjust;
1cfb7d1e 4713
88967714
AM
4714 if (this_hdr->sh_type != SHT_NOBITS)
4715 {
32812159
AM
4716 if (p->p_filesz + adjust < p->p_memsz)
4717 {
4718 /* We have a PROGBITS section following NOBITS ones.
4719 Allocate file space for the NOBITS section(s) and
4720 zero it. */
4721 adjust = p->p_memsz - p->p_filesz;
4722 if (!write_zeros (abfd, off, adjust))
4723 return FALSE;
4724 }
88967714
AM
4725 off += adjust;
4726 p->p_filesz += adjust;
252b5132 4727 }
252b5132
RH
4728 }
4729
4730 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4731 {
b301b248
AM
4732 /* The section at i == 0 is the one that actually contains
4733 everything. */
4a938328
MS
4734 if (i == 0)
4735 {
627b32bc 4736 this_hdr->sh_offset = sec->filepos = off;
6a3cd2b4
AM
4737 off += this_hdr->sh_size;
4738 p->p_filesz = this_hdr->sh_size;
b301b248
AM
4739 p->p_memsz = 0;
4740 p->p_align = 1;
252b5132 4741 }
4a938328 4742 else
252b5132 4743 {
b301b248 4744 /* The rest are fake sections that shouldn't be written. */
252b5132 4745 sec->filepos = 0;
eea6121a 4746 sec->size = 0;
b301b248
AM
4747 sec->flags = 0;
4748 continue;
252b5132 4749 }
252b5132
RH
4750 }
4751 else
4752 {
1e951488 4753 if (p->p_type == PT_LOAD)
b301b248 4754 {
1e951488
AM
4755 this_hdr->sh_offset = sec->filepos = off;
4756 if (this_hdr->sh_type != SHT_NOBITS)
4757 off += this_hdr->sh_size;
4758 }
4759 else if (this_hdr->sh_type == SHT_NOBITS
4760 && (this_hdr->sh_flags & SHF_TLS) != 0
4761 && this_hdr->sh_offset == 0)
4762 {
4763 /* This is a .tbss section that didn't get a PT_LOAD.
4764 (See _bfd_elf_map_sections_to_segments "Create a
4765 final PT_LOAD".) Set sh_offset to the value it
4766 would have if we had created a zero p_filesz and
4767 p_memsz PT_LOAD header for the section. This
4768 also makes the PT_TLS header have the same
4769 p_offset value. */
4770 bfd_vma adjust = vma_page_aligned_bias (this_hdr->sh_addr,
4771 off, align);
4772 this_hdr->sh_offset = sec->filepos = off + adjust;
b301b248 4773 }
252b5132 4774
02bf8d82 4775 if (this_hdr->sh_type != SHT_NOBITS)
b301b248 4776 {
6a3cd2b4 4777 p->p_filesz += this_hdr->sh_size;
02bf8d82
AM
4778 /* A load section without SHF_ALLOC is something like
4779 a note section in a PT_NOTE segment. These take
4780 file space but are not loaded into memory. */
4781 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
6a3cd2b4 4782 p->p_memsz += this_hdr->sh_size;
b301b248 4783 }
6a3cd2b4 4784 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
13ae64f3 4785 {
6a3cd2b4
AM
4786 if (p->p_type == PT_TLS)
4787 p->p_memsz += this_hdr->sh_size;
4788
4789 /* .tbss is special. It doesn't contribute to p_memsz of
4790 normal segments. */
4791 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4792 p->p_memsz += this_hdr->sh_size;
13ae64f3
JJ
4793 }
4794
b10a8ae0
L
4795 if (align > p->p_align
4796 && !m->p_align_valid
4797 && (p->p_type != PT_LOAD
4798 || (abfd->flags & D_PAGED) == 0))
252b5132
RH
4799 p->p_align = align;
4800 }
4801
bf988460 4802 if (!m->p_flags_valid)
252b5132
RH
4803 {
4804 p->p_flags |= PF_R;
02bf8d82 4805 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
252b5132 4806 p->p_flags |= PF_X;
02bf8d82 4807 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
252b5132
RH
4808 p->p_flags |= PF_W;
4809 }
4810 }
43a8475c 4811
bf988460 4812 off -= off_adjust;
0920dee7 4813
7c928300
AM
4814 /* Check that all sections are in a PT_LOAD segment.
4815 Don't check funky gdb generated core files. */
4816 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
9a83a553
AM
4817 {
4818 bfd_boolean check_vma = TRUE;
4819
4820 for (i = 1; i < m->count; i++)
4821 if (m->sections[i]->vma == m->sections[i - 1]->vma
4822 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i])
4823 ->this_hdr), p) != 0
4824 && ELF_SECTION_SIZE (&(elf_section_data (m->sections[i - 1])
4825 ->this_hdr), p) != 0)
0920dee7 4826 {
9a83a553
AM
4827 /* Looks like we have overlays packed into the segment. */
4828 check_vma = FALSE;
4829 break;
0920dee7 4830 }
9a83a553
AM
4831
4832 for (i = 0; i < m->count; i++)
4833 {
4834 Elf_Internal_Shdr *this_hdr;
4835 asection *sec;
4836
4837 sec = m->sections[i];
4838 this_hdr = &(elf_section_data(sec)->this_hdr);
86b2281f
AM
4839 if (!ELF_SECTION_IN_SEGMENT_1 (this_hdr, p, check_vma, 0)
4840 && !ELF_TBSS_SPECIAL (this_hdr, p))
9a83a553
AM
4841 {
4842 (*_bfd_error_handler)
4843 (_("%B: section `%A' can't be allocated in segment %d"),
4844 abfd, sec, j);
4845 print_segment_map (m);
4846 }
4847 }
4848 }
252b5132
RH
4849 }
4850
12bd6957 4851 elf_next_file_pos (abfd) = off;
f3520d2f
AM
4852 return TRUE;
4853}
4854
4855/* Assign file positions for the other sections. */
4856
4857static bfd_boolean
4858assign_file_positions_for_non_load_sections (bfd *abfd,
4859 struct bfd_link_info *link_info)
4860{
4861 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4862 Elf_Internal_Shdr **i_shdrpp;
4863 Elf_Internal_Shdr **hdrpp;
4864 Elf_Internal_Phdr *phdrs;
4865 Elf_Internal_Phdr *p;
4866 struct elf_segment_map *m;
62655c7b 4867 struct elf_segment_map *hdrs_segment;
f3520d2f
AM
4868 bfd_vma filehdr_vaddr, filehdr_paddr;
4869 bfd_vma phdrs_vaddr, phdrs_paddr;
4870 file_ptr off;
4871 unsigned int num_sec;
4872 unsigned int i;
4873 unsigned int count;
4874
5c182d5f
AM
4875 i_shdrpp = elf_elfsections (abfd);
4876 num_sec = elf_numsections (abfd);
12bd6957 4877 off = elf_next_file_pos (abfd);
5c182d5f
AM
4878 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4879 {
5c182d5f
AM
4880 Elf_Internal_Shdr *hdr;
4881
4882 hdr = *hdrpp;
4883 if (hdr->bfd_section != NULL
252e386e
AM
4884 && (hdr->bfd_section->filepos != 0
4885 || (hdr->sh_type == SHT_NOBITS
4886 && hdr->contents == NULL)))
627b32bc 4887 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5c182d5f
AM
4888 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4889 {
e8d2ba53
AM
4890 if (hdr->sh_size != 0)
4891 (*_bfd_error_handler)
4892 (_("%B: warning: allocated section `%s' not in segment"),
4893 abfd,
4894 (hdr->bfd_section == NULL
4895 ? "*unknown*"
4896 : hdr->bfd_section->name));
3ba71138
L
4897 /* We don't need to page align empty sections. */
4898 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5c182d5f
AM
4899 off += vma_page_aligned_bias (hdr->sh_addr, off,
4900 bed->maxpagesize);
4901 else
4902 off += vma_page_aligned_bias (hdr->sh_addr, off,
4903 hdr->sh_addralign);
4904 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4905 FALSE);
4906 }
4907 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4908 && hdr->bfd_section == NULL)
12bd6957
AM
4909 || hdr == i_shdrpp[elf_onesymtab (abfd)]
4910 || hdr == i_shdrpp[elf_symtab_shndx (abfd)]
4911 || hdr == i_shdrpp[elf_strtab_sec (abfd)])
5c182d5f
AM
4912 hdr->sh_offset = -1;
4913 else
4914 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5c182d5f
AM
4915 }
4916
252b5132
RH
4917 /* Now that we have set the section file positions, we can set up
4918 the file positions for the non PT_LOAD segments. */
f3520d2f
AM
4919 count = 0;
4920 filehdr_vaddr = 0;
4921 filehdr_paddr = 0;
4922 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4923 phdrs_paddr = 0;
62655c7b 4924 hdrs_segment = NULL;
f3520d2f 4925 phdrs = elf_tdata (abfd)->phdr;
12bd6957 4926 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
f3520d2f
AM
4927 {
4928 ++count;
4929 if (p->p_type != PT_LOAD)
4930 continue;
4931
4932 if (m->includes_filehdr)
4933 {
4934 filehdr_vaddr = p->p_vaddr;
4935 filehdr_paddr = p->p_paddr;
4936 }
4937 if (m->includes_phdrs)
4938 {
4939 phdrs_vaddr = p->p_vaddr;
4940 phdrs_paddr = p->p_paddr;
4941 if (m->includes_filehdr)
4942 {
62655c7b 4943 hdrs_segment = m;
f3520d2f
AM
4944 phdrs_vaddr += bed->s->sizeof_ehdr;
4945 phdrs_paddr += bed->s->sizeof_ehdr;
4946 }
4947 }
4948 }
4949
62655c7b
RM
4950 if (hdrs_segment != NULL && link_info != NULL)
4951 {
4952 /* There is a segment that contains both the file headers and the
4953 program headers, so provide a symbol __ehdr_start pointing there.
4954 A program can use this to examine itself robustly. */
4955
4956 struct elf_link_hash_entry *hash
4957 = elf_link_hash_lookup (elf_hash_table (link_info), "__ehdr_start",
4958 FALSE, FALSE, TRUE);
4959 /* If the symbol was referenced and not defined, define it. */
4960 if (hash != NULL
4961 && (hash->root.type == bfd_link_hash_new
4962 || hash->root.type == bfd_link_hash_undefined
4963 || hash->root.type == bfd_link_hash_undefweak
4964 || hash->root.type == bfd_link_hash_common))
4965 {
4966 asection *s = NULL;
4967 if (hdrs_segment->count != 0)
4968 /* The segment contains sections, so use the first one. */
4969 s = hdrs_segment->sections[0];
4970 else
4971 /* Use the first (i.e. lowest-addressed) section in any segment. */
12bd6957 4972 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
62655c7b
RM
4973 if (m->count != 0)
4974 {
4975 s = m->sections[0];
4976 break;
4977 }
4978
4979 if (s != NULL)
4980 {
4981 hash->root.u.def.value = filehdr_vaddr - s->vma;
4982 hash->root.u.def.section = s;
4983 }
4984 else
4985 {
4986 hash->root.u.def.value = filehdr_vaddr;
4987 hash->root.u.def.section = bfd_abs_section_ptr;
4988 }
4989
4990 hash->root.type = bfd_link_hash_defined;
4991 hash->def_regular = 1;
4992 hash->non_elf = 0;
4993 }
4994 }
4995
12bd6957 4996 for (m = elf_seg_map (abfd), p = phdrs; m != NULL; m = m->next, p++)
252b5132 4997 {
129af99f 4998 if (p->p_type == PT_GNU_RELRO)
252b5132 4999 {
b84a33b5 5000 const Elf_Internal_Phdr *lp;
3146fac4 5001 struct elf_segment_map *lm;
1ea63fd2 5002
129af99f 5003 if (link_info != NULL)
8c37241b 5004 {
129af99f
AS
5005 /* During linking the range of the RELRO segment is passed
5006 in link_info. */
12bd6957 5007 for (lm = elf_seg_map (abfd), lp = phdrs;
3146fac4
AM
5008 lm != NULL;
5009 lm = lm->next, lp++)
8c37241b
JJ
5010 {
5011 if (lp->p_type == PT_LOAD
b84a33b5 5012 && lp->p_vaddr < link_info->relro_end
3146fac4
AM
5013 && lm->count != 0
5014 && lm->sections[0]->vma >= link_info->relro_start)
8c37241b
JJ
5015 break;
5016 }
8981c88a 5017
3146fac4 5018 BFD_ASSERT (lm != NULL);
8c37241b 5019 }
129af99f
AS
5020 else
5021 {
5022 /* Otherwise we are copying an executable or shared
b84a33b5 5023 library, but we need to use the same linker logic. */
129af99f
AS
5024 for (lp = phdrs; lp < phdrs + count; ++lp)
5025 {
5026 if (lp->p_type == PT_LOAD
5027 && lp->p_paddr == p->p_paddr)
5028 break;
5029 }
b84a33b5
AM
5030 }
5031
5032 if (lp < phdrs + count)
5033 {
5034 p->p_vaddr = lp->p_vaddr;
5035 p->p_paddr = lp->p_paddr;
5036 p->p_offset = lp->p_offset;
5037 if (link_info != NULL)
5038 p->p_filesz = link_info->relro_end - lp->p_vaddr;
5039 else if (m->p_size_valid)
5040 p->p_filesz = m->p_size;
129af99f
AS
5041 else
5042 abort ();
b84a33b5 5043 p->p_memsz = p->p_filesz;
f3944f72
L
5044 /* Preserve the alignment and flags if they are valid. The
5045 gold linker generates RW/4 for the PT_GNU_RELRO section.
5046 It is better for objcopy/strip to honor these attributes
5047 otherwise gdb will choke when using separate debug files.
5048 */
5049 if (!m->p_align_valid)
5050 p->p_align = 1;
5051 if (!m->p_flags_valid)
5052 p->p_flags = (lp->p_flags & ~PF_W);
129af99f 5053 }
9433b9b1 5054 else
b84a33b5
AM
5055 {
5056 memset (p, 0, sizeof *p);
5057 p->p_type = PT_NULL;
5058 }
129af99f 5059 }
04c3a755
NS
5060 else if (p->p_type == PT_GNU_STACK)
5061 {
5062 if (m->p_size_valid)
5063 p->p_memsz = m->p_size;
5064 }
129af99f
AS
5065 else if (m->count != 0)
5066 {
5067 if (p->p_type != PT_LOAD
5068 && (p->p_type != PT_NOTE
5069 || bfd_get_format (abfd) != bfd_core))
5070 {
129af99f
AS
5071 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
5072
86b2281f 5073 p->p_filesz = 0;
129af99f 5074 p->p_offset = m->sections[0]->filepos;
86b2281f
AM
5075 for (i = m->count; i-- != 0;)
5076 {
5077 asection *sect = m->sections[i];
5078 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
5079 if (hdr->sh_type != SHT_NOBITS)
5080 {
5081 p->p_filesz = (sect->filepos - m->sections[0]->filepos
5082 + hdr->sh_size);
5083 break;
5084 }
5085 }
129af99f
AS
5086 }
5087 }
5088 else if (m->includes_filehdr)
5089 {
5090 p->p_vaddr = filehdr_vaddr;
5091 if (! m->p_paddr_valid)
5092 p->p_paddr = filehdr_paddr;
5093 }
5094 else if (m->includes_phdrs)
5095 {
5096 p->p_vaddr = phdrs_vaddr;
5097 if (! m->p_paddr_valid)
5098 p->p_paddr = phdrs_paddr;
252b5132
RH
5099 }
5100 }
5101
12bd6957 5102 elf_next_file_pos (abfd) = off;
252b5132 5103
b34976b6 5104 return TRUE;
252b5132
RH
5105}
5106
252b5132
RH
5107/* Work out the file positions of all the sections. This is called by
5108 _bfd_elf_compute_section_file_positions. All the section sizes and
5109 VMAs must be known before this is called.
5110
e0638f70
AM
5111 Reloc sections come in two flavours: Those processed specially as
5112 "side-channel" data attached to a section to which they apply, and
5113 those that bfd doesn't process as relocations. The latter sort are
5114 stored in a normal bfd section by bfd_section_from_shdr. We don't
5115 consider the former sort here, unless they form part of the loadable
5116 image. Reloc sections not assigned here will be handled later by
5117 assign_file_positions_for_relocs.
252b5132
RH
5118
5119 We also don't set the positions of the .symtab and .strtab here. */
5120
b34976b6 5121static bfd_boolean
c84fca4d
AO
5122assign_file_positions_except_relocs (bfd *abfd,
5123 struct bfd_link_info *link_info)
252b5132 5124{
5c182d5f
AM
5125 struct elf_obj_tdata *tdata = elf_tdata (abfd);
5126 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
252b5132 5127 file_ptr off;
9c5bfbb7 5128 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH
5129
5130 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
5131 && bfd_get_format (abfd) != bfd_core)
5132 {
5c182d5f
AM
5133 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
5134 unsigned int num_sec = elf_numsections (abfd);
252b5132
RH
5135 Elf_Internal_Shdr **hdrpp;
5136 unsigned int i;
5137
5138 /* Start after the ELF header. */
5139 off = i_ehdrp->e_ehsize;
5140
5141 /* We are not creating an executable, which means that we are
5142 not creating a program header, and that the actual order of
5143 the sections in the file is unimportant. */
9ad5cbcf 5144 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH
5145 {
5146 Elf_Internal_Shdr *hdr;
5147
5148 hdr = *hdrpp;
e0638f70
AM
5149 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5150 && hdr->bfd_section == NULL)
12bd6957
AM
5151 || i == elf_onesymtab (abfd)
5152 || i == elf_symtab_shndx (abfd)
5153 || i == elf_strtab_sec (abfd))
252b5132
RH
5154 {
5155 hdr->sh_offset = -1;
252b5132 5156 }
9ad5cbcf 5157 else
b34976b6 5158 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132
RH
5159 }
5160 }
5161 else
5162 {
f3520d2f
AM
5163 unsigned int alloc;
5164
252b5132 5165 /* Assign file positions for the loaded sections based on the
08a40648 5166 assignment of sections to segments. */
f3520d2f
AM
5167 if (!assign_file_positions_for_load_sections (abfd, link_info))
5168 return FALSE;
5169
5170 /* And for non-load sections. */
5171 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
5172 return FALSE;
5173
e36284ab
AM
5174 if (bed->elf_backend_modify_program_headers != NULL)
5175 {
5176 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
5177 return FALSE;
5178 }
5179
58e7ebac
L
5180 /* Set e_type in ELF header to ET_EXEC for -pie -Ttext-segment=. */
5181 if (link_info != NULL
5182 && link_info->executable
5183 && link_info->shared)
5184 {
5185 unsigned int num_segments = elf_elfheader (abfd)->e_phnum;
5186 Elf_Internal_Phdr *segment = elf_tdata (abfd)->phdr;
5187 Elf_Internal_Phdr *end_segment = &segment[num_segments];
5188
5189 /* Find the lowest p_vaddr in PT_LOAD segments. */
5190 bfd_vma p_vaddr = (bfd_vma) -1;
5191 for (; segment < end_segment; segment++)
5192 if (segment->p_type == PT_LOAD && p_vaddr > segment->p_vaddr)
5193 p_vaddr = segment->p_vaddr;
5194
5195 /* Set e_type to ET_EXEC if the lowest p_vaddr in PT_LOAD
5196 segments is non-zero. */
5197 if (p_vaddr)
5198 i_ehdrp->e_type = ET_EXEC;
5199 }
5200
f3520d2f 5201 /* Write out the program headers. */
12bd6957 5202 alloc = elf_program_header_size (abfd) / bed->s->sizeof_phdr;
f3520d2f
AM
5203 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
5204 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
b34976b6 5205 return FALSE;
252b5132 5206
12bd6957 5207 off = elf_next_file_pos (abfd);
252b5132
RH
5208 }
5209
5210 /* Place the section headers. */
45d6a902 5211 off = align_file_position (off, 1 << bed->s->log_file_align);
252b5132
RH
5212 i_ehdrp->e_shoff = off;
5213 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
5214
12bd6957 5215 elf_next_file_pos (abfd) = off;
252b5132 5216
b34976b6 5217 return TRUE;
252b5132
RH
5218}
5219
b34976b6 5220static bfd_boolean
217aa764 5221prep_headers (bfd *abfd)
252b5132 5222{
3d540e93 5223 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
2b0f7ef9 5224 struct elf_strtab_hash *shstrtab;
9c5bfbb7 5225 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH
5226
5227 i_ehdrp = elf_elfheader (abfd);
252b5132 5228
2b0f7ef9 5229 shstrtab = _bfd_elf_strtab_init ();
252b5132 5230 if (shstrtab == NULL)
b34976b6 5231 return FALSE;
252b5132
RH
5232
5233 elf_shstrtab (abfd) = shstrtab;
5234
5235 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
5236 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
5237 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
5238 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
5239
5240 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
5241 i_ehdrp->e_ident[EI_DATA] =
5242 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
5243 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
5244
252b5132
RH
5245 if ((abfd->flags & DYNAMIC) != 0)
5246 i_ehdrp->e_type = ET_DYN;
5247 else if ((abfd->flags & EXEC_P) != 0)
5248 i_ehdrp->e_type = ET_EXEC;
5249 else if (bfd_get_format (abfd) == bfd_core)
5250 i_ehdrp->e_type = ET_CORE;
5251 else
5252 i_ehdrp->e_type = ET_REL;
5253
5254 switch (bfd_get_arch (abfd))
5255 {
5256 case bfd_arch_unknown:
5257 i_ehdrp->e_machine = EM_NONE;
5258 break;
aa4f99bb
AO
5259
5260 /* There used to be a long list of cases here, each one setting
5261 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5262 in the corresponding bfd definition. To avoid duplication,
5263 the switch was removed. Machines that need special handling
5264 can generally do it in elf_backend_final_write_processing(),
5265 unless they need the information earlier than the final write.
5266 Such need can generally be supplied by replacing the tests for
5267 e_machine with the conditions used to determine it. */
252b5132 5268 default:
9c5bfbb7
AM
5269 i_ehdrp->e_machine = bed->elf_machine_code;
5270 }
aa4f99bb 5271
252b5132
RH
5272 i_ehdrp->e_version = bed->s->ev_current;
5273 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5274
c044fabd 5275 /* No program header, for now. */
252b5132
RH
5276 i_ehdrp->e_phoff = 0;
5277 i_ehdrp->e_phentsize = 0;
5278 i_ehdrp->e_phnum = 0;
5279
c044fabd 5280 /* Each bfd section is section header entry. */
252b5132
RH
5281 i_ehdrp->e_entry = bfd_get_start_address (abfd);
5282 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5283
c044fabd 5284 /* If we're building an executable, we'll need a program header table. */
252b5132 5285 if (abfd->flags & EXEC_P)
0e71e495
BE
5286 /* It all happens later. */
5287 ;
252b5132
RH
5288 else
5289 {
5290 i_ehdrp->e_phentsize = 0;
252b5132
RH
5291 i_ehdrp->e_phoff = 0;
5292 }
5293
5294 elf_tdata (abfd)->symtab_hdr.sh_name =
b34976b6 5295 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
252b5132 5296 elf_tdata (abfd)->strtab_hdr.sh_name =
b34976b6 5297 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
252b5132 5298 elf_tdata (abfd)->shstrtab_hdr.sh_name =
b34976b6 5299 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
252b5132
RH
5300 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5301 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5302 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
b34976b6 5303 return FALSE;
252b5132 5304
b34976b6 5305 return TRUE;
252b5132
RH
5306}
5307
5308/* Assign file positions for all the reloc sections which are not part
5309 of the loadable file image. */
5310
5311void
217aa764 5312_bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
252b5132
RH
5313{
5314 file_ptr off;
9ad5cbcf 5315 unsigned int i, num_sec;
252b5132
RH
5316 Elf_Internal_Shdr **shdrpp;
5317
12bd6957 5318 off = elf_next_file_pos (abfd);
252b5132 5319
9ad5cbcf
AM
5320 num_sec = elf_numsections (abfd);
5321 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
252b5132
RH
5322 {
5323 Elf_Internal_Shdr *shdrp;
5324
5325 shdrp = *shdrpp;
5326 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
5327 && shdrp->sh_offset == -1)
b34976b6 5328 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
252b5132
RH
5329 }
5330
12bd6957 5331 elf_next_file_pos (abfd) = off;
252b5132
RH
5332}
5333
b34976b6 5334bfd_boolean
217aa764 5335_bfd_elf_write_object_contents (bfd *abfd)
252b5132 5336{
9c5bfbb7 5337 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 5338 Elf_Internal_Shdr **i_shdrp;
b34976b6 5339 bfd_boolean failed;
9ad5cbcf 5340 unsigned int count, num_sec;
30e8ee25 5341 struct elf_obj_tdata *t;
252b5132
RH
5342
5343 if (! abfd->output_has_begun
217aa764 5344 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 5345 return FALSE;
252b5132
RH
5346
5347 i_shdrp = elf_elfsections (abfd);
252b5132 5348
b34976b6 5349 failed = FALSE;
252b5132
RH
5350 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5351 if (failed)
b34976b6 5352 return FALSE;
252b5132
RH
5353
5354 _bfd_elf_assign_file_positions_for_relocs (abfd);
5355
c044fabd 5356 /* After writing the headers, we need to write the sections too... */
9ad5cbcf
AM
5357 num_sec = elf_numsections (abfd);
5358 for (count = 1; count < num_sec; count++)
252b5132
RH
5359 {
5360 if (bed->elf_backend_section_processing)
5361 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5362 if (i_shdrp[count]->contents)
5363 {
dc810e39
AM
5364 bfd_size_type amt = i_shdrp[count]->sh_size;
5365
252b5132 5366 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
dc810e39 5367 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
b34976b6 5368 return FALSE;
252b5132
RH
5369 }
5370 }
5371
5372 /* Write out the section header names. */
30e8ee25 5373 t = elf_tdata (abfd);
26ae6d5e 5374 if (elf_shstrtab (abfd) != NULL
30e8ee25 5375 && (bfd_seek (abfd, t->shstrtab_hdr.sh_offset, SEEK_SET) != 0
08a40648 5376 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
b34976b6 5377 return FALSE;
252b5132
RH
5378
5379 if (bed->elf_backend_final_write_processing)
12bd6957 5380 (*bed->elf_backend_final_write_processing) (abfd, elf_linker (abfd));
252b5132 5381
ff59fc36
RM
5382 if (!bed->s->write_shdrs_and_ehdr (abfd))
5383 return FALSE;
5384
5385 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
c0355132
AM
5386 if (t->o->build_id.after_write_object_contents != NULL)
5387 return (*t->o->build_id.after_write_object_contents) (abfd);
ff59fc36
RM
5388
5389 return TRUE;
252b5132
RH
5390}
5391
b34976b6 5392bfd_boolean
217aa764 5393_bfd_elf_write_corefile_contents (bfd *abfd)
252b5132 5394{
c044fabd 5395 /* Hopefully this can be done just like an object file. */
252b5132
RH
5396 return _bfd_elf_write_object_contents (abfd);
5397}
c044fabd
KH
5398
5399/* Given a section, search the header to find them. */
5400
cb33740c 5401unsigned int
198beae2 5402_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
252b5132 5403{
9c5bfbb7 5404 const struct elf_backend_data *bed;
91d6fa6a 5405 unsigned int sec_index;
252b5132 5406
9ad5cbcf
AM
5407 if (elf_section_data (asect) != NULL
5408 && elf_section_data (asect)->this_idx != 0)
5409 return elf_section_data (asect)->this_idx;
5410
5411 if (bfd_is_abs_section (asect))
91d6fa6a 5412 sec_index = SHN_ABS;
af746e92 5413 else if (bfd_is_com_section (asect))
91d6fa6a 5414 sec_index = SHN_COMMON;
af746e92 5415 else if (bfd_is_und_section (asect))
91d6fa6a 5416 sec_index = SHN_UNDEF;
af746e92 5417 else
91d6fa6a 5418 sec_index = SHN_BAD;
252b5132 5419
af746e92 5420 bed = get_elf_backend_data (abfd);
252b5132
RH
5421 if (bed->elf_backend_section_from_bfd_section)
5422 {
91d6fa6a 5423 int retval = sec_index;
9ad5cbcf 5424
af746e92
AM
5425 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5426 return retval;
252b5132
RH
5427 }
5428
91d6fa6a 5429 if (sec_index == SHN_BAD)
af746e92 5430 bfd_set_error (bfd_error_nonrepresentable_section);
252b5132 5431
91d6fa6a 5432 return sec_index;
252b5132
RH
5433}
5434
5435/* Given a BFD symbol, return the index in the ELF symbol table, or -1
5436 on error. */
5437
5438int
217aa764 5439_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
252b5132
RH
5440{
5441 asymbol *asym_ptr = *asym_ptr_ptr;
5442 int idx;
5443 flagword flags = asym_ptr->flags;
5444
5445 /* When gas creates relocations against local labels, it creates its
5446 own symbol for the section, but does put the symbol into the
5447 symbol chain, so udata is 0. When the linker is generating
5448 relocatable output, this section symbol may be for one of the
5449 input sections rather than the output section. */
5450 if (asym_ptr->udata.i == 0
5451 && (flags & BSF_SECTION_SYM)
5452 && asym_ptr->section)
5453 {
5372391b 5454 asection *sec;
252b5132
RH
5455 int indx;
5456
5372391b
AM
5457 sec = asym_ptr->section;
5458 if (sec->owner != abfd && sec->output_section != NULL)
5459 sec = sec->output_section;
5460 if (sec->owner == abfd
5461 && (indx = sec->index) < elf_num_section_syms (abfd)
4e89ac30 5462 && elf_section_syms (abfd)[indx] != NULL)
252b5132
RH
5463 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5464 }
5465
5466 idx = asym_ptr->udata.i;
5467
5468 if (idx == 0)
5469 {
5470 /* This case can occur when using --strip-symbol on a symbol
08a40648 5471 which is used in a relocation entry. */
252b5132 5472 (*_bfd_error_handler)
d003868e
AM
5473 (_("%B: symbol `%s' required but not present"),
5474 abfd, bfd_asymbol_name (asym_ptr));
252b5132
RH
5475 bfd_set_error (bfd_error_no_symbols);
5476 return -1;
5477 }
5478
5479#if DEBUG & 4
5480 {
5481 fprintf (stderr,
9ccb8af9
AM
5482 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5483 (long) asym_ptr, asym_ptr->name, idx, (long) flags);
252b5132
RH
5484 fflush (stderr);
5485 }
5486#endif
5487
5488 return idx;
5489}
5490
84d1d650 5491/* Rewrite program header information. */
252b5132 5492
b34976b6 5493static bfd_boolean
84d1d650 5494rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
252b5132 5495{
b34976b6
AM
5496 Elf_Internal_Ehdr *iehdr;
5497 struct elf_segment_map *map;
5498 struct elf_segment_map *map_first;
5499 struct elf_segment_map **pointer_to_map;
5500 Elf_Internal_Phdr *segment;
5501 asection *section;
5502 unsigned int i;
5503 unsigned int num_segments;
5504 bfd_boolean phdr_included = FALSE;
5c44b38e 5505 bfd_boolean p_paddr_valid;
b34976b6
AM
5506 bfd_vma maxpagesize;
5507 struct elf_segment_map *phdr_adjust_seg = NULL;
5508 unsigned int phdr_adjust_num = 0;
9c5bfbb7 5509 const struct elf_backend_data *bed;
bc67d8a6 5510
caf47ea6 5511 bed = get_elf_backend_data (ibfd);
252b5132
RH
5512 iehdr = elf_elfheader (ibfd);
5513
bc67d8a6 5514 map_first = NULL;
c044fabd 5515 pointer_to_map = &map_first;
252b5132
RH
5516
5517 num_segments = elf_elfheader (ibfd)->e_phnum;
bc67d8a6
NC
5518 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5519
5520 /* Returns the end address of the segment + 1. */
aecc8f8a
AM
5521#define SEGMENT_END(segment, start) \
5522 (start + (segment->p_memsz > segment->p_filesz \
5523 ? segment->p_memsz : segment->p_filesz))
bc67d8a6 5524
eecdbe52
JJ
5525#define SECTION_SIZE(section, segment) \
5526 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5527 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
eea6121a 5528 ? section->size : 0)
eecdbe52 5529
b34976b6 5530 /* Returns TRUE if the given section is contained within
bc67d8a6 5531 the given segment. VMA addresses are compared. */
aecc8f8a
AM
5532#define IS_CONTAINED_BY_VMA(section, segment) \
5533 (section->vma >= segment->p_vaddr \
eecdbe52 5534 && (section->vma + SECTION_SIZE (section, segment) \
aecc8f8a 5535 <= (SEGMENT_END (segment, segment->p_vaddr))))
c044fabd 5536
b34976b6 5537 /* Returns TRUE if the given section is contained within
bc67d8a6 5538 the given segment. LMA addresses are compared. */
aecc8f8a
AM
5539#define IS_CONTAINED_BY_LMA(section, segment, base) \
5540 (section->lma >= base \
eecdbe52 5541 && (section->lma + SECTION_SIZE (section, segment) \
aecc8f8a 5542 <= SEGMENT_END (segment, base)))
252b5132 5543
0efc80c8
L
5544 /* Handle PT_NOTE segment. */
5545#define IS_NOTE(p, s) \
aecc8f8a 5546 (p->p_type == PT_NOTE \
0efc80c8 5547 && elf_section_type (s) == SHT_NOTE \
aecc8f8a 5548 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 5549 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 5550 <= p->p_offset + p->p_filesz))
252b5132 5551
0efc80c8
L
5552 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5553 etc. */
5554#define IS_COREFILE_NOTE(p, s) \
5555 (IS_NOTE (p, s) \
5556 && bfd_get_format (ibfd) == bfd_core \
5557 && s->vma == 0 \
5558 && s->lma == 0)
5559
252b5132
RH
5560 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5561 linker, which generates a PT_INTERP section with p_vaddr and
5562 p_memsz set to 0. */
aecc8f8a
AM
5563#define IS_SOLARIS_PT_INTERP(p, s) \
5564 (p->p_vaddr == 0 \
5565 && p->p_paddr == 0 \
5566 && p->p_memsz == 0 \
5567 && p->p_filesz > 0 \
5568 && (s->flags & SEC_HAS_CONTENTS) != 0 \
eea6121a 5569 && s->size > 0 \
aecc8f8a 5570 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 5571 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 5572 <= p->p_offset + p->p_filesz))
5c440b1e 5573
bc67d8a6
NC
5574 /* Decide if the given section should be included in the given segment.
5575 A section will be included if:
f5ffc919 5576 1. It is within the address space of the segment -- we use the LMA
08a40648 5577 if that is set for the segment and the VMA otherwise,
0efc80c8 5578 2. It is an allocated section or a NOTE section in a PT_NOTE
d324f6d6 5579 segment.
bc67d8a6 5580 3. There is an output section associated with it,
eecdbe52 5581 4. The section has not already been allocated to a previous segment.
2b05f1b7 5582 5. PT_GNU_STACK segments do not include any sections.
03394ac9 5583 6. PT_TLS segment includes only SHF_TLS sections.
6f79b219
JJ
5584 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5585 8. PT_DYNAMIC should not contain empty sections at the beginning
08a40648 5586 (with the possible exception of .dynamic). */
9f17e2a6 5587#define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
2b05f1b7
L
5588 ((((segment->p_paddr \
5589 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5590 : IS_CONTAINED_BY_VMA (section, segment)) \
5591 && (section->flags & SEC_ALLOC) != 0) \
0efc80c8 5592 || IS_NOTE (segment, section)) \
2b05f1b7
L
5593 && segment->p_type != PT_GNU_STACK \
5594 && (segment->p_type != PT_TLS \
5595 || (section->flags & SEC_THREAD_LOCAL)) \
5596 && (segment->p_type == PT_LOAD \
5597 || segment->p_type == PT_TLS \
5598 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5599 && (segment->p_type != PT_DYNAMIC \
5600 || SECTION_SIZE (section, segment) > 0 \
5601 || (segment->p_paddr \
5602 ? segment->p_paddr != section->lma \
5603 : segment->p_vaddr != section->vma) \
5604 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5605 == 0)) \
0067a569 5606 && !section->segment_mark)
bc67d8a6 5607
9f17e2a6
L
5608/* If the output section of a section in the input segment is NULL,
5609 it is removed from the corresponding output segment. */
5610#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5611 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5612 && section->output_section != NULL)
5613
b34976b6 5614 /* Returns TRUE iff seg1 starts after the end of seg2. */
b5f852ea
NC
5615#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5616 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5617
5618 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5619 their VMA address ranges and their LMA address ranges overlap.
5620 It is possible to have overlapping VMA ranges without overlapping LMA
5621 ranges. RedBoot images for example can have both .data and .bss mapped
5622 to the same VMA range, but with the .data section mapped to a different
5623 LMA. */
aecc8f8a 5624#define SEGMENT_OVERLAPS(seg1, seg2) \
b5f852ea 5625 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
08a40648 5626 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
b5f852ea 5627 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
08a40648 5628 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
bc67d8a6
NC
5629
5630 /* Initialise the segment mark field. */
5631 for (section = ibfd->sections; section != NULL; section = section->next)
b34976b6 5632 section->segment_mark = FALSE;
bc67d8a6 5633
5c44b38e
AM
5634 /* The Solaris linker creates program headers in which all the
5635 p_paddr fields are zero. When we try to objcopy or strip such a
5636 file, we get confused. Check for this case, and if we find it
5637 don't set the p_paddr_valid fields. */
5638 p_paddr_valid = FALSE;
5639 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5640 i < num_segments;
5641 i++, segment++)
5642 if (segment->p_paddr != 0)
5643 {
5644 p_paddr_valid = TRUE;
5645 break;
5646 }
5647
252b5132 5648 /* Scan through the segments specified in the program header
bc67d8a6 5649 of the input BFD. For this first scan we look for overlaps
9ad5cbcf 5650 in the loadable segments. These can be created by weird
aecc8f8a 5651 parameters to objcopy. Also, fix some solaris weirdness. */
bc67d8a6
NC
5652 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5653 i < num_segments;
c044fabd 5654 i++, segment++)
252b5132 5655 {
252b5132 5656 unsigned int j;
c044fabd 5657 Elf_Internal_Phdr *segment2;
252b5132 5658
aecc8f8a
AM
5659 if (segment->p_type == PT_INTERP)
5660 for (section = ibfd->sections; section; section = section->next)
5661 if (IS_SOLARIS_PT_INTERP (segment, section))
5662 {
5663 /* Mininal change so that the normal section to segment
4cc11e76 5664 assignment code will work. */
aecc8f8a
AM
5665 segment->p_vaddr = section->vma;
5666 break;
5667 }
5668
bc67d8a6 5669 if (segment->p_type != PT_LOAD)
b10a8ae0
L
5670 {
5671 /* Remove PT_GNU_RELRO segment. */
5672 if (segment->p_type == PT_GNU_RELRO)
5673 segment->p_type = PT_NULL;
5674 continue;
5675 }
c044fabd 5676
bc67d8a6 5677 /* Determine if this segment overlaps any previous segments. */
0067a569 5678 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
bc67d8a6
NC
5679 {
5680 bfd_signed_vma extra_length;
c044fabd 5681
bc67d8a6 5682 if (segment2->p_type != PT_LOAD
0067a569 5683 || !SEGMENT_OVERLAPS (segment, segment2))
bc67d8a6 5684 continue;
c044fabd 5685
bc67d8a6
NC
5686 /* Merge the two segments together. */
5687 if (segment2->p_vaddr < segment->p_vaddr)
5688 {
c044fabd 5689 /* Extend SEGMENT2 to include SEGMENT and then delete
08a40648 5690 SEGMENT. */
0067a569
AM
5691 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5692 - SEGMENT_END (segment2, segment2->p_vaddr));
c044fabd 5693
bc67d8a6
NC
5694 if (extra_length > 0)
5695 {
0067a569 5696 segment2->p_memsz += extra_length;
bc67d8a6
NC
5697 segment2->p_filesz += extra_length;
5698 }
c044fabd 5699
bc67d8a6 5700 segment->p_type = PT_NULL;
c044fabd 5701
bc67d8a6
NC
5702 /* Since we have deleted P we must restart the outer loop. */
5703 i = 0;
5704 segment = elf_tdata (ibfd)->phdr;
5705 break;
5706 }
5707 else
5708 {
c044fabd 5709 /* Extend SEGMENT to include SEGMENT2 and then delete
08a40648 5710 SEGMENT2. */
0067a569
AM
5711 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5712 - SEGMENT_END (segment, segment->p_vaddr));
c044fabd 5713
bc67d8a6
NC
5714 if (extra_length > 0)
5715 {
0067a569 5716 segment->p_memsz += extra_length;
bc67d8a6
NC
5717 segment->p_filesz += extra_length;
5718 }
c044fabd 5719
bc67d8a6
NC
5720 segment2->p_type = PT_NULL;
5721 }
5722 }
5723 }
c044fabd 5724
bc67d8a6
NC
5725 /* The second scan attempts to assign sections to segments. */
5726 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5727 i < num_segments;
0067a569 5728 i++, segment++)
bc67d8a6 5729 {
0067a569
AM
5730 unsigned int section_count;
5731 asection **sections;
5732 asection *output_section;
5733 unsigned int isec;
5734 bfd_vma matching_lma;
5735 bfd_vma suggested_lma;
5736 unsigned int j;
dc810e39 5737 bfd_size_type amt;
0067a569
AM
5738 asection *first_section;
5739 bfd_boolean first_matching_lma;
5740 bfd_boolean first_suggested_lma;
bc67d8a6
NC
5741
5742 if (segment->p_type == PT_NULL)
5743 continue;
c044fabd 5744
9f17e2a6 5745 first_section = NULL;
bc67d8a6 5746 /* Compute how many sections might be placed into this segment. */
b5f852ea
NC
5747 for (section = ibfd->sections, section_count = 0;
5748 section != NULL;
5749 section = section->next)
9f17e2a6
L
5750 {
5751 /* Find the first section in the input segment, which may be
5752 removed from the corresponding output segment. */
5753 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5754 {
5755 if (first_section == NULL)
5756 first_section = section;
5757 if (section->output_section != NULL)
5758 ++section_count;
5759 }
5760 }
811072d8 5761
b5f852ea
NC
5762 /* Allocate a segment map big enough to contain
5763 all of the sections we have selected. */
dc810e39
AM
5764 amt = sizeof (struct elf_segment_map);
5765 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
a50b1753 5766 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 5767 if (map == NULL)
b34976b6 5768 return FALSE;
252b5132
RH
5769
5770 /* Initialise the fields of the segment map. Default to
5771 using the physical address of the segment in the input BFD. */
0067a569
AM
5772 map->next = NULL;
5773 map->p_type = segment->p_type;
5774 map->p_flags = segment->p_flags;
bc67d8a6 5775 map->p_flags_valid = 1;
55d55ac7 5776
9f17e2a6
L
5777 /* If the first section in the input segment is removed, there is
5778 no need to preserve segment physical address in the corresponding
5779 output segment. */
945c025a 5780 if (!first_section || first_section->output_section != NULL)
9f17e2a6
L
5781 {
5782 map->p_paddr = segment->p_paddr;
5c44b38e 5783 map->p_paddr_valid = p_paddr_valid;
9f17e2a6 5784 }
252b5132
RH
5785
5786 /* Determine if this segment contains the ELF file header
5787 and if it contains the program headers themselves. */
bc67d8a6
NC
5788 map->includes_filehdr = (segment->p_offset == 0
5789 && segment->p_filesz >= iehdr->e_ehsize);
bc67d8a6 5790 map->includes_phdrs = 0;
252b5132 5791
0067a569 5792 if (!phdr_included || segment->p_type != PT_LOAD)
252b5132 5793 {
bc67d8a6
NC
5794 map->includes_phdrs =
5795 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5796 && (segment->p_offset + segment->p_filesz
252b5132
RH
5797 >= ((bfd_vma) iehdr->e_phoff
5798 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 5799
bc67d8a6 5800 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 5801 phdr_included = TRUE;
252b5132
RH
5802 }
5803
bc67d8a6 5804 if (section_count == 0)
252b5132
RH
5805 {
5806 /* Special segments, such as the PT_PHDR segment, may contain
5807 no sections, but ordinary, loadable segments should contain
1ed89aa9
NC
5808 something. They are allowed by the ELF spec however, so only
5809 a warning is produced. */
bc67d8a6 5810 if (segment->p_type == PT_LOAD)
0067a569
AM
5811 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5812 " detected, is this intentional ?\n"),
5813 ibfd);
252b5132 5814
bc67d8a6 5815 map->count = 0;
c044fabd
KH
5816 *pointer_to_map = map;
5817 pointer_to_map = &map->next;
252b5132
RH
5818
5819 continue;
5820 }
5821
5822 /* Now scan the sections in the input BFD again and attempt
5823 to add their corresponding output sections to the segment map.
5824 The problem here is how to handle an output section which has
5825 been moved (ie had its LMA changed). There are four possibilities:
5826
5827 1. None of the sections have been moved.
5828 In this case we can continue to use the segment LMA from the
5829 input BFD.
5830
5831 2. All of the sections have been moved by the same amount.
5832 In this case we can change the segment's LMA to match the LMA
5833 of the first section.
5834
5835 3. Some of the sections have been moved, others have not.
5836 In this case those sections which have not been moved can be
5837 placed in the current segment which will have to have its size,
5838 and possibly its LMA changed, and a new segment or segments will
5839 have to be created to contain the other sections.
5840
b5f852ea 5841 4. The sections have been moved, but not by the same amount.
252b5132
RH
5842 In this case we can change the segment's LMA to match the LMA
5843 of the first section and we will have to create a new segment
5844 or segments to contain the other sections.
5845
5846 In order to save time, we allocate an array to hold the section
5847 pointers that we are interested in. As these sections get assigned
5848 to a segment, they are removed from this array. */
5849
a50b1753 5850 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
252b5132 5851 if (sections == NULL)
b34976b6 5852 return FALSE;
252b5132
RH
5853
5854 /* Step One: Scan for segment vs section LMA conflicts.
5855 Also add the sections to the section array allocated above.
5856 Also add the sections to the current segment. In the common
5857 case, where the sections have not been moved, this means that
5858 we have completely filled the segment, and there is nothing
5859 more to do. */
252b5132 5860 isec = 0;
72730e0c 5861 matching_lma = 0;
252b5132 5862 suggested_lma = 0;
0067a569
AM
5863 first_matching_lma = TRUE;
5864 first_suggested_lma = TRUE;
252b5132 5865
147d51c2 5866 for (section = ibfd->sections;
bc67d8a6
NC
5867 section != NULL;
5868 section = section->next)
147d51c2
L
5869 if (section == first_section)
5870 break;
5871
5872 for (j = 0; section != NULL; section = section->next)
252b5132 5873 {
caf47ea6 5874 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 5875 {
bc67d8a6
NC
5876 output_section = section->output_section;
5877
0067a569 5878 sections[j++] = section;
252b5132
RH
5879
5880 /* The Solaris native linker always sets p_paddr to 0.
5881 We try to catch that case here, and set it to the
5e8d7549
NC
5882 correct value. Note - some backends require that
5883 p_paddr be left as zero. */
5c44b38e 5884 if (!p_paddr_valid
4455705d 5885 && segment->p_vaddr != 0
0067a569 5886 && !bed->want_p_paddr_set_to_zero
252b5132 5887 && isec == 0
bc67d8a6 5888 && output_section->lma != 0
0067a569
AM
5889 && output_section->vma == (segment->p_vaddr
5890 + (map->includes_filehdr
5891 ? iehdr->e_ehsize
5892 : 0)
5893 + (map->includes_phdrs
5894 ? (iehdr->e_phnum
5895 * iehdr->e_phentsize)
5896 : 0)))
bc67d8a6 5897 map->p_paddr = segment->p_vaddr;
252b5132
RH
5898
5899 /* Match up the physical address of the segment with the
5900 LMA address of the output section. */
bc67d8a6 5901 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549 5902 || IS_COREFILE_NOTE (segment, section)
0067a569
AM
5903 || (bed->want_p_paddr_set_to_zero
5904 && IS_CONTAINED_BY_VMA (output_section, segment)))
252b5132 5905 {
0067a569
AM
5906 if (first_matching_lma || output_section->lma < matching_lma)
5907 {
5908 matching_lma = output_section->lma;
5909 first_matching_lma = FALSE;
5910 }
252b5132
RH
5911
5912 /* We assume that if the section fits within the segment
bc67d8a6 5913 then it does not overlap any other section within that
252b5132 5914 segment. */
0067a569
AM
5915 map->sections[isec++] = output_section;
5916 }
5917 else if (first_suggested_lma)
5918 {
5919 suggested_lma = output_section->lma;
5920 first_suggested_lma = FALSE;
252b5132 5921 }
147d51c2
L
5922
5923 if (j == section_count)
5924 break;
252b5132
RH
5925 }
5926 }
5927
bc67d8a6 5928 BFD_ASSERT (j == section_count);
252b5132
RH
5929
5930 /* Step Two: Adjust the physical address of the current segment,
5931 if necessary. */
bc67d8a6 5932 if (isec == section_count)
252b5132
RH
5933 {
5934 /* All of the sections fitted within the segment as currently
5935 specified. This is the default case. Add the segment to
5936 the list of built segments and carry on to process the next
5937 program header in the input BFD. */
bc67d8a6 5938 map->count = section_count;
c044fabd
KH
5939 *pointer_to_map = map;
5940 pointer_to_map = &map->next;
08a40648 5941
5c44b38e
AM
5942 if (p_paddr_valid
5943 && !bed->want_p_paddr_set_to_zero
147d51c2 5944 && matching_lma != map->p_paddr
5c44b38e
AM
5945 && !map->includes_filehdr
5946 && !map->includes_phdrs)
3271a814
NS
5947 /* There is some padding before the first section in the
5948 segment. So, we must account for that in the output
5949 segment's vma. */
5950 map->p_vaddr_offset = matching_lma - map->p_paddr;
08a40648 5951
252b5132
RH
5952 free (sections);
5953 continue;
5954 }
252b5132
RH
5955 else
5956 {
0067a569 5957 if (!first_matching_lma)
72730e0c
AM
5958 {
5959 /* At least one section fits inside the current segment.
5960 Keep it, but modify its physical address to match the
5961 LMA of the first section that fitted. */
bc67d8a6 5962 map->p_paddr = matching_lma;
72730e0c
AM
5963 }
5964 else
5965 {
5966 /* None of the sections fitted inside the current segment.
5967 Change the current segment's physical address to match
5968 the LMA of the first section. */
bc67d8a6 5969 map->p_paddr = suggested_lma;
72730e0c
AM
5970 }
5971
bc67d8a6
NC
5972 /* Offset the segment physical address from the lma
5973 to allow for space taken up by elf headers. */
5974 if (map->includes_filehdr)
010c8431
AM
5975 {
5976 if (map->p_paddr >= iehdr->e_ehsize)
5977 map->p_paddr -= iehdr->e_ehsize;
5978 else
5979 {
5980 map->includes_filehdr = FALSE;
5981 map->includes_phdrs = FALSE;
5982 }
5983 }
252b5132 5984
bc67d8a6
NC
5985 if (map->includes_phdrs)
5986 {
010c8431
AM
5987 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5988 {
5989 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5990
5991 /* iehdr->e_phnum is just an estimate of the number
5992 of program headers that we will need. Make a note
5993 here of the number we used and the segment we chose
5994 to hold these headers, so that we can adjust the
5995 offset when we know the correct value. */
5996 phdr_adjust_num = iehdr->e_phnum;
5997 phdr_adjust_seg = map;
5998 }
5999 else
6000 map->includes_phdrs = FALSE;
bc67d8a6 6001 }
252b5132
RH
6002 }
6003
6004 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 6005 those that fit to the current segment and removing them from the
252b5132
RH
6006 sections array; but making sure not to leave large gaps. Once all
6007 possible sections have been assigned to the current segment it is
6008 added to the list of built segments and if sections still remain
6009 to be assigned, a new segment is constructed before repeating
6010 the loop. */
6011 isec = 0;
6012 do
6013 {
bc67d8a6 6014 map->count = 0;
252b5132 6015 suggested_lma = 0;
0067a569 6016 first_suggested_lma = TRUE;
252b5132
RH
6017
6018 /* Fill the current segment with sections that fit. */
bc67d8a6 6019 for (j = 0; j < section_count; j++)
252b5132 6020 {
bc67d8a6 6021 section = sections[j];
252b5132 6022
bc67d8a6 6023 if (section == NULL)
252b5132
RH
6024 continue;
6025
bc67d8a6 6026 output_section = section->output_section;
252b5132 6027
bc67d8a6 6028 BFD_ASSERT (output_section != NULL);
c044fabd 6029
bc67d8a6
NC
6030 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
6031 || IS_COREFILE_NOTE (segment, section))
252b5132 6032 {
bc67d8a6 6033 if (map->count == 0)
252b5132
RH
6034 {
6035 /* If the first section in a segment does not start at
bc67d8a6
NC
6036 the beginning of the segment, then something is
6037 wrong. */
0067a569
AM
6038 if (output_section->lma
6039 != (map->p_paddr
6040 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
6041 + (map->includes_phdrs
6042 ? iehdr->e_phnum * iehdr->e_phentsize
6043 : 0)))
252b5132
RH
6044 abort ();
6045 }
6046 else
6047 {
0067a569 6048 asection *prev_sec;
252b5132 6049
bc67d8a6 6050 prev_sec = map->sections[map->count - 1];
252b5132
RH
6051
6052 /* If the gap between the end of the previous section
bc67d8a6
NC
6053 and the start of this section is more than
6054 maxpagesize then we need to start a new segment. */
eea6121a 6055 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 6056 maxpagesize)
caf47ea6 6057 < BFD_ALIGN (output_section->lma, maxpagesize))
0067a569 6058 || (prev_sec->lma + prev_sec->size
079e9a2f 6059 > output_section->lma))
252b5132 6060 {
0067a569
AM
6061 if (first_suggested_lma)
6062 {
6063 suggested_lma = output_section->lma;
6064 first_suggested_lma = FALSE;
6065 }
252b5132
RH
6066
6067 continue;
6068 }
6069 }
6070
bc67d8a6 6071 map->sections[map->count++] = output_section;
252b5132
RH
6072 ++isec;
6073 sections[j] = NULL;
b34976b6 6074 section->segment_mark = TRUE;
252b5132 6075 }
0067a569
AM
6076 else if (first_suggested_lma)
6077 {
6078 suggested_lma = output_section->lma;
6079 first_suggested_lma = FALSE;
6080 }
252b5132
RH
6081 }
6082
bc67d8a6 6083 BFD_ASSERT (map->count > 0);
252b5132
RH
6084
6085 /* Add the current segment to the list of built segments. */
c044fabd
KH
6086 *pointer_to_map = map;
6087 pointer_to_map = &map->next;
252b5132 6088
bc67d8a6 6089 if (isec < section_count)
252b5132
RH
6090 {
6091 /* We still have not allocated all of the sections to
6092 segments. Create a new segment here, initialise it
6093 and carry on looping. */
dc810e39
AM
6094 amt = sizeof (struct elf_segment_map);
6095 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
5964fc3a 6096 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 6097 if (map == NULL)
5ed6aba4
NC
6098 {
6099 free (sections);
6100 return FALSE;
6101 }
252b5132
RH
6102
6103 /* Initialise the fields of the segment map. Set the physical
6104 physical address to the LMA of the first section that has
6105 not yet been assigned. */
0067a569
AM
6106 map->next = NULL;
6107 map->p_type = segment->p_type;
6108 map->p_flags = segment->p_flags;
6109 map->p_flags_valid = 1;
6110 map->p_paddr = suggested_lma;
5c44b38e 6111 map->p_paddr_valid = p_paddr_valid;
bc67d8a6 6112 map->includes_filehdr = 0;
0067a569 6113 map->includes_phdrs = 0;
252b5132
RH
6114 }
6115 }
bc67d8a6 6116 while (isec < section_count);
252b5132
RH
6117
6118 free (sections);
6119 }
6120
12bd6957 6121 elf_seg_map (obfd) = map_first;
bc67d8a6
NC
6122
6123 /* If we had to estimate the number of program headers that were
9ad5cbcf 6124 going to be needed, then check our estimate now and adjust
bc67d8a6
NC
6125 the offset if necessary. */
6126 if (phdr_adjust_seg != NULL)
6127 {
6128 unsigned int count;
c044fabd 6129
bc67d8a6 6130 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 6131 count++;
252b5132 6132
bc67d8a6
NC
6133 if (count > phdr_adjust_num)
6134 phdr_adjust_seg->p_paddr
6135 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
6136 }
c044fabd 6137
bc67d8a6 6138#undef SEGMENT_END
eecdbe52 6139#undef SECTION_SIZE
bc67d8a6
NC
6140#undef IS_CONTAINED_BY_VMA
6141#undef IS_CONTAINED_BY_LMA
0efc80c8 6142#undef IS_NOTE
252b5132 6143#undef IS_COREFILE_NOTE
bc67d8a6 6144#undef IS_SOLARIS_PT_INTERP
9f17e2a6 6145#undef IS_SECTION_IN_INPUT_SEGMENT
bc67d8a6
NC
6146#undef INCLUDE_SECTION_IN_SEGMENT
6147#undef SEGMENT_AFTER_SEGMENT
6148#undef SEGMENT_OVERLAPS
b34976b6 6149 return TRUE;
252b5132
RH
6150}
6151
84d1d650
L
6152/* Copy ELF program header information. */
6153
6154static bfd_boolean
6155copy_elf_program_header (bfd *ibfd, bfd *obfd)
6156{
6157 Elf_Internal_Ehdr *iehdr;
6158 struct elf_segment_map *map;
6159 struct elf_segment_map *map_first;
6160 struct elf_segment_map **pointer_to_map;
6161 Elf_Internal_Phdr *segment;
6162 unsigned int i;
6163 unsigned int num_segments;
6164 bfd_boolean phdr_included = FALSE;
88967714 6165 bfd_boolean p_paddr_valid;
84d1d650
L
6166
6167 iehdr = elf_elfheader (ibfd);
6168
6169 map_first = NULL;
6170 pointer_to_map = &map_first;
6171
88967714
AM
6172 /* If all the segment p_paddr fields are zero, don't set
6173 map->p_paddr_valid. */
6174 p_paddr_valid = FALSE;
84d1d650 6175 num_segments = elf_elfheader (ibfd)->e_phnum;
88967714
AM
6176 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6177 i < num_segments;
6178 i++, segment++)
6179 if (segment->p_paddr != 0)
6180 {
6181 p_paddr_valid = TRUE;
6182 break;
6183 }
6184
84d1d650
L
6185 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6186 i < num_segments;
6187 i++, segment++)
6188 {
6189 asection *section;
6190 unsigned int section_count;
6191 bfd_size_type amt;
6192 Elf_Internal_Shdr *this_hdr;
53020534 6193 asection *first_section = NULL;
a76e6f2f 6194 asection *lowest_section;
84d1d650 6195
84d1d650
L
6196 /* Compute how many sections are in this segment. */
6197 for (section = ibfd->sections, section_count = 0;
6198 section != NULL;
6199 section = section->next)
6200 {
6201 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 6202 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
3271a814 6203 {
a76e6f2f
AM
6204 if (first_section == NULL)
6205 first_section = section;
3271a814
NS
6206 section_count++;
6207 }
84d1d650
L
6208 }
6209
6210 /* Allocate a segment map big enough to contain
6211 all of the sections we have selected. */
6212 amt = sizeof (struct elf_segment_map);
6213 if (section_count != 0)
6214 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
a50b1753 6215 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
84d1d650
L
6216 if (map == NULL)
6217 return FALSE;
6218
6219 /* Initialize the fields of the output segment map with the
6220 input segment. */
6221 map->next = NULL;
6222 map->p_type = segment->p_type;
6223 map->p_flags = segment->p_flags;
6224 map->p_flags_valid = 1;
6225 map->p_paddr = segment->p_paddr;
88967714 6226 map->p_paddr_valid = p_paddr_valid;
3f570048
AM
6227 map->p_align = segment->p_align;
6228 map->p_align_valid = 1;
3271a814 6229 map->p_vaddr_offset = 0;
84d1d650 6230
04c3a755
NS
6231 if (map->p_type == PT_GNU_RELRO
6232 || map->p_type == PT_GNU_STACK)
b10a8ae0
L
6233 {
6234 /* The PT_GNU_RELRO segment may contain the first a few
6235 bytes in the .got.plt section even if the whole .got.plt
6236 section isn't in the PT_GNU_RELRO segment. We won't
04c3a755
NS
6237 change the size of the PT_GNU_RELRO segment.
6238 Similarly, PT_GNU_STACK size is significant on uclinux
6239 systems. */
9433b9b1 6240 map->p_size = segment->p_memsz;
b10a8ae0
L
6241 map->p_size_valid = 1;
6242 }
6243
84d1d650
L
6244 /* Determine if this segment contains the ELF file header
6245 and if it contains the program headers themselves. */
6246 map->includes_filehdr = (segment->p_offset == 0
6247 && segment->p_filesz >= iehdr->e_ehsize);
6248
6249 map->includes_phdrs = 0;
6250 if (! phdr_included || segment->p_type != PT_LOAD)
6251 {
6252 map->includes_phdrs =
6253 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6254 && (segment->p_offset + segment->p_filesz
6255 >= ((bfd_vma) iehdr->e_phoff
6256 + iehdr->e_phnum * iehdr->e_phentsize)));
6257
6258 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6259 phdr_included = TRUE;
6260 }
6261
a76e6f2f 6262 lowest_section = first_section;
84d1d650
L
6263 if (section_count != 0)
6264 {
6265 unsigned int isec = 0;
6266
53020534 6267 for (section = first_section;
84d1d650
L
6268 section != NULL;
6269 section = section->next)
6270 {
6271 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 6272 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
53020534
L
6273 {
6274 map->sections[isec++] = section->output_section;
a76e6f2f
AM
6275 if ((section->flags & SEC_ALLOC) != 0)
6276 {
6277 bfd_vma seg_off;
6278
fb8a5684
AM
6279 if (section->lma < lowest_section->lma)
6280 lowest_section = section;
6281
a76e6f2f
AM
6282 /* Section lmas are set up from PT_LOAD header
6283 p_paddr in _bfd_elf_make_section_from_shdr.
6284 If this header has a p_paddr that disagrees
6285 with the section lma, flag the p_paddr as
6286 invalid. */
6287 if ((section->flags & SEC_LOAD) != 0)
6288 seg_off = this_hdr->sh_offset - segment->p_offset;
6289 else
6290 seg_off = this_hdr->sh_addr - segment->p_vaddr;
6291 if (section->lma - segment->p_paddr != seg_off)
6292 map->p_paddr_valid = FALSE;
6293 }
53020534
L
6294 if (isec == section_count)
6295 break;
6296 }
84d1d650
L
6297 }
6298 }
6299
a76e6f2f
AM
6300 if (map->includes_filehdr && lowest_section != NULL)
6301 /* We need to keep the space used by the headers fixed. */
6302 map->header_size = lowest_section->vma - segment->p_vaddr;
d324f6d6 6303
a76e6f2f
AM
6304 if (!map->includes_phdrs
6305 && !map->includes_filehdr
6306 && map->p_paddr_valid)
6307 /* There is some other padding before the first section. */
6308 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
6309 - segment->p_paddr);
6310
84d1d650
L
6311 map->count = section_count;
6312 *pointer_to_map = map;
6313 pointer_to_map = &map->next;
6314 }
6315
12bd6957 6316 elf_seg_map (obfd) = map_first;
84d1d650
L
6317 return TRUE;
6318}
6319
6320/* Copy private BFD data. This copies or rewrites ELF program header
6321 information. */
6322
6323static bfd_boolean
6324copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6325{
84d1d650
L
6326 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6327 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6328 return TRUE;
6329
6330 if (elf_tdata (ibfd)->phdr == NULL)
6331 return TRUE;
6332
6333 if (ibfd->xvec == obfd->xvec)
6334 {
cb3ff1e5
NC
6335 /* Check to see if any sections in the input BFD
6336 covered by ELF program header have changed. */
d55ce4e2 6337 Elf_Internal_Phdr *segment;
84d1d650
L
6338 asection *section, *osec;
6339 unsigned int i, num_segments;
6340 Elf_Internal_Shdr *this_hdr;
147d51c2
L
6341 const struct elf_backend_data *bed;
6342
6343 bed = get_elf_backend_data (ibfd);
6344
6345 /* Regenerate the segment map if p_paddr is set to 0. */
6346 if (bed->want_p_paddr_set_to_zero)
6347 goto rewrite;
84d1d650
L
6348
6349 /* Initialize the segment mark field. */
6350 for (section = obfd->sections; section != NULL;
6351 section = section->next)
6352 section->segment_mark = FALSE;
6353
6354 num_segments = elf_elfheader (ibfd)->e_phnum;
6355 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6356 i < num_segments;
6357 i++, segment++)
6358 {
5f6999aa
NC
6359 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6360 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6361 which severly confuses things, so always regenerate the segment
6362 map in this case. */
6363 if (segment->p_paddr == 0
6364 && segment->p_memsz == 0
6365 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
cb3ff1e5 6366 goto rewrite;
5f6999aa 6367
84d1d650
L
6368 for (section = ibfd->sections;
6369 section != NULL; section = section->next)
6370 {
6371 /* We mark the output section so that we know it comes
6372 from the input BFD. */
6373 osec = section->output_section;
6374 if (osec)
6375 osec->segment_mark = TRUE;
6376
6377 /* Check if this section is covered by the segment. */
6378 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 6379 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
84d1d650
L
6380 {
6381 /* FIXME: Check if its output section is changed or
6382 removed. What else do we need to check? */
6383 if (osec == NULL
6384 || section->flags != osec->flags
6385 || section->lma != osec->lma
6386 || section->vma != osec->vma
6387 || section->size != osec->size
6388 || section->rawsize != osec->rawsize
6389 || section->alignment_power != osec->alignment_power)
6390 goto rewrite;
6391 }
6392 }
6393 }
6394
cb3ff1e5 6395 /* Check to see if any output section do not come from the
84d1d650
L
6396 input BFD. */
6397 for (section = obfd->sections; section != NULL;
6398 section = section->next)
6399 {
6400 if (section->segment_mark == FALSE)
6401 goto rewrite;
6402 else
6403 section->segment_mark = FALSE;
6404 }
6405
6406 return copy_elf_program_header (ibfd, obfd);
6407 }
6408
6409rewrite:
f1d85785
L
6410 if (ibfd->xvec == obfd->xvec)
6411 {
6412 /* When rewriting program header, set the output maxpagesize to
6413 the maximum alignment of input PT_LOAD segments. */
6414 Elf_Internal_Phdr *segment;
6415 unsigned int i;
6416 unsigned int num_segments = elf_elfheader (ibfd)->e_phnum;
6417 bfd_vma maxpagesize = 0;
6418
6419 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6420 i < num_segments;
6421 i++, segment++)
6422 if (segment->p_type == PT_LOAD
6423 && maxpagesize < segment->p_align)
6424 maxpagesize = segment->p_align;
6425
6426 if (maxpagesize != get_elf_backend_data (obfd)->maxpagesize)
6427 bfd_emul_set_maxpagesize (bfd_get_target (obfd), maxpagesize);
6428 }
6429
84d1d650
L
6430 return rewrite_elf_program_header (ibfd, obfd);
6431}
6432
ccd2ec6a
L
6433/* Initialize private output section information from input section. */
6434
6435bfd_boolean
6436_bfd_elf_init_private_section_data (bfd *ibfd,
6437 asection *isec,
6438 bfd *obfd,
6439 asection *osec,
6440 struct bfd_link_info *link_info)
6441
6442{
6443 Elf_Internal_Shdr *ihdr, *ohdr;
dfa7b0b8 6444 bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
ccd2ec6a
L
6445
6446 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6447 || obfd->xvec->flavour != bfd_target_elf_flavour)
6448 return TRUE;
6449
ba85c43e
NC
6450 BFD_ASSERT (elf_section_data (osec) != NULL);
6451
dfa7b0b8
AM
6452 /* For objcopy and relocatable link, don't copy the output ELF
6453 section type from input if the output BFD section flags have been
6454 set to something different. For a final link allow some flags
6455 that the linker clears to differ. */
42bb2e33 6456 if (elf_section_type (osec) == SHT_NULL
dfa7b0b8
AM
6457 && (osec->flags == isec->flags
6458 || (final_link
6459 && ((osec->flags ^ isec->flags)
0814be7d 6460 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
42bb2e33 6461 elf_section_type (osec) = elf_section_type (isec);
d270463e
L
6462
6463 /* FIXME: Is this correct for all OS/PROC specific flags? */
6464 elf_section_flags (osec) |= (elf_section_flags (isec)
6465 & (SHF_MASKOS | SHF_MASKPROC));
ccd2ec6a
L
6466
6467 /* Set things up for objcopy and relocatable link. The output
6468 SHT_GROUP section will have its elf_next_in_group pointing back
6469 to the input group members. Ignore linker created group section.
6470 See elfNN_ia64_object_p in elfxx-ia64.c. */
dfa7b0b8 6471 if (!final_link)
ccd2ec6a
L
6472 {
6473 if (elf_sec_group (isec) == NULL
6474 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6475 {
6476 if (elf_section_flags (isec) & SHF_GROUP)
6477 elf_section_flags (osec) |= SHF_GROUP;
6478 elf_next_in_group (osec) = elf_next_in_group (isec);
9659de1c 6479 elf_section_data (osec)->group = elf_section_data (isec)->group;
ccd2ec6a
L
6480 }
6481 }
6482
6483 ihdr = &elf_section_data (isec)->this_hdr;
6484
6485 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6486 don't use the output section of the linked-to section since it
6487 may be NULL at this point. */
6488 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6489 {
6490 ohdr = &elf_section_data (osec)->this_hdr;
6491 ohdr->sh_flags |= SHF_LINK_ORDER;
6492 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6493 }
6494
6495 osec->use_rela_p = isec->use_rela_p;
6496
6497 return TRUE;
6498}
6499
252b5132
RH
6500/* Copy private section information. This copies over the entsize
6501 field, and sometimes the info field. */
6502
b34976b6 6503bfd_boolean
217aa764
AM
6504_bfd_elf_copy_private_section_data (bfd *ibfd,
6505 asection *isec,
6506 bfd *obfd,
6507 asection *osec)
252b5132
RH
6508{
6509 Elf_Internal_Shdr *ihdr, *ohdr;
6510
6511 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6512 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 6513 return TRUE;
252b5132 6514
252b5132
RH
6515 ihdr = &elf_section_data (isec)->this_hdr;
6516 ohdr = &elf_section_data (osec)->this_hdr;
6517
6518 ohdr->sh_entsize = ihdr->sh_entsize;
6519
6520 if (ihdr->sh_type == SHT_SYMTAB
6521 || ihdr->sh_type == SHT_DYNSYM
6522 || ihdr->sh_type == SHT_GNU_verneed
6523 || ihdr->sh_type == SHT_GNU_verdef)
6524 ohdr->sh_info = ihdr->sh_info;
6525
ccd2ec6a
L
6526 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6527 NULL);
252b5132
RH
6528}
6529
d0bf826b
AM
6530/* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6531 necessary if we are removing either the SHT_GROUP section or any of
6532 the group member sections. DISCARDED is the value that a section's
6533 output_section has if the section will be discarded, NULL when this
6534 function is called from objcopy, bfd_abs_section_ptr when called
6535 from the linker. */
80fccad2
BW
6536
6537bfd_boolean
d0bf826b 6538_bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
80fccad2 6539{
30288845
AM
6540 asection *isec;
6541
30288845 6542 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
415f38a6 6543 if (elf_section_type (isec) == SHT_GROUP)
30288845
AM
6544 {
6545 asection *first = elf_next_in_group (isec);
6546 asection *s = first;
d0bf826b
AM
6547 bfd_size_type removed = 0;
6548
30288845
AM
6549 while (s != NULL)
6550 {
415f38a6
AM
6551 /* If this member section is being output but the
6552 SHT_GROUP section is not, then clear the group info
6553 set up by _bfd_elf_copy_private_section_data. */
d0bf826b
AM
6554 if (s->output_section != discarded
6555 && isec->output_section == discarded)
30288845
AM
6556 {
6557 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6558 elf_group_name (s->output_section) = NULL;
6559 }
415f38a6
AM
6560 /* Conversely, if the member section is not being output
6561 but the SHT_GROUP section is, then adjust its size. */
d0bf826b
AM
6562 else if (s->output_section == discarded
6563 && isec->output_section != discarded)
6564 removed += 4;
30288845
AM
6565 s = elf_next_in_group (s);
6566 if (s == first)
6567 break;
6568 }
d0bf826b
AM
6569 if (removed != 0)
6570 {
6571 if (discarded != NULL)
6572 {
6573 /* If we've been called for ld -r, then we need to
6574 adjust the input section size. This function may
6575 be called multiple times, so save the original
6576 size. */
6577 if (isec->rawsize == 0)
6578 isec->rawsize = isec->size;
6579 isec->size = isec->rawsize - removed;
6580 }
6581 else
6582 {
6583 /* Adjust the output section size when called from
6584 objcopy. */
6585 isec->output_section->size -= removed;
6586 }
6587 }
30288845
AM
6588 }
6589
80fccad2
BW
6590 return TRUE;
6591}
6592
d0bf826b
AM
6593/* Copy private header information. */
6594
6595bfd_boolean
6596_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6597{
6598 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6599 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6600 return TRUE;
6601
6602 /* Copy over private BFD data if it has not already been copied.
6603 This must be done here, rather than in the copy_private_bfd_data
6604 entry point, because the latter is called after the section
6605 contents have been set, which means that the program headers have
6606 already been worked out. */
12bd6957 6607 if (elf_seg_map (obfd) == NULL && elf_tdata (ibfd)->phdr != NULL)
d0bf826b
AM
6608 {
6609 if (! copy_private_bfd_data (ibfd, obfd))
6610 return FALSE;
6611 }
6612
6613 return _bfd_elf_fixup_group_sections (ibfd, NULL);
6614}
6615
252b5132
RH
6616/* Copy private symbol information. If this symbol is in a section
6617 which we did not map into a BFD section, try to map the section
6618 index correctly. We use special macro definitions for the mapped
6619 section indices; these definitions are interpreted by the
6620 swap_out_syms function. */
6621
9ad5cbcf
AM
6622#define MAP_ONESYMTAB (SHN_HIOS + 1)
6623#define MAP_DYNSYMTAB (SHN_HIOS + 2)
6624#define MAP_STRTAB (SHN_HIOS + 3)
6625#define MAP_SHSTRTAB (SHN_HIOS + 4)
6626#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 6627
b34976b6 6628bfd_boolean
217aa764
AM
6629_bfd_elf_copy_private_symbol_data (bfd *ibfd,
6630 asymbol *isymarg,
6631 bfd *obfd,
6632 asymbol *osymarg)
252b5132
RH
6633{
6634 elf_symbol_type *isym, *osym;
6635
6636 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6637 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 6638 return TRUE;
252b5132
RH
6639
6640 isym = elf_symbol_from (ibfd, isymarg);
6641 osym = elf_symbol_from (obfd, osymarg);
6642
6643 if (isym != NULL
8424d8f5 6644 && isym->internal_elf_sym.st_shndx != 0
252b5132
RH
6645 && osym != NULL
6646 && bfd_is_abs_section (isym->symbol.section))
6647 {
6648 unsigned int shndx;
6649
6650 shndx = isym->internal_elf_sym.st_shndx;
6651 if (shndx == elf_onesymtab (ibfd))
6652 shndx = MAP_ONESYMTAB;
6653 else if (shndx == elf_dynsymtab (ibfd))
6654 shndx = MAP_DYNSYMTAB;
12bd6957 6655 else if (shndx == elf_strtab_sec (ibfd))
252b5132 6656 shndx = MAP_STRTAB;
12bd6957 6657 else if (shndx == elf_shstrtab_sec (ibfd))
252b5132 6658 shndx = MAP_SHSTRTAB;
12bd6957 6659 else if (shndx == elf_symtab_shndx (ibfd))
9ad5cbcf 6660 shndx = MAP_SYM_SHNDX;
252b5132
RH
6661 osym->internal_elf_sym.st_shndx = shndx;
6662 }
6663
b34976b6 6664 return TRUE;
252b5132
RH
6665}
6666
6667/* Swap out the symbols. */
6668
b34976b6 6669static bfd_boolean
217aa764
AM
6670swap_out_syms (bfd *abfd,
6671 struct bfd_strtab_hash **sttp,
6672 int relocatable_p)
252b5132 6673{
9c5bfbb7 6674 const struct elf_backend_data *bed;
079e9a2f
AM
6675 int symcount;
6676 asymbol **syms;
6677 struct bfd_strtab_hash *stt;
6678 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 6679 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f 6680 Elf_Internal_Shdr *symstrtab_hdr;
f075ee0c
AM
6681 bfd_byte *outbound_syms;
6682 bfd_byte *outbound_shndx;
079e9a2f 6683 int idx;
12bd6957 6684 unsigned int num_locals;
079e9a2f 6685 bfd_size_type amt;
174fd7f9 6686 bfd_boolean name_local_sections;
252b5132 6687
12bd6957 6688 if (!elf_map_symbols (abfd, &num_locals))
b34976b6 6689 return FALSE;
252b5132 6690
c044fabd 6691 /* Dump out the symtabs. */
079e9a2f
AM
6692 stt = _bfd_elf_stringtab_init ();
6693 if (stt == NULL)
b34976b6 6694 return FALSE;
252b5132 6695
079e9a2f
AM
6696 bed = get_elf_backend_data (abfd);
6697 symcount = bfd_get_symcount (abfd);
6698 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6699 symtab_hdr->sh_type = SHT_SYMTAB;
6700 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6701 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
12bd6957 6702 symtab_hdr->sh_info = num_locals + 1;
72de5009 6703 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
079e9a2f
AM
6704
6705 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6706 symstrtab_hdr->sh_type = SHT_STRTAB;
6707
a50b1753
NC
6708 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6709 bed->s->sizeof_sym);
079e9a2f 6710 if (outbound_syms == NULL)
5ed6aba4
NC
6711 {
6712 _bfd_stringtab_free (stt);
6713 return FALSE;
6714 }
217aa764 6715 symtab_hdr->contents = outbound_syms;
252b5132 6716
9ad5cbcf
AM
6717 outbound_shndx = NULL;
6718 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6719 if (symtab_shndx_hdr->sh_name != 0)
6720 {
6721 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
a50b1753
NC
6722 outbound_shndx = (bfd_byte *)
6723 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
9ad5cbcf 6724 if (outbound_shndx == NULL)
5ed6aba4
NC
6725 {
6726 _bfd_stringtab_free (stt);
6727 return FALSE;
6728 }
6729
9ad5cbcf
AM
6730 symtab_shndx_hdr->contents = outbound_shndx;
6731 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6732 symtab_shndx_hdr->sh_size = amt;
6733 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6734 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6735 }
6736
589e6347 6737 /* Now generate the data (for "contents"). */
079e9a2f
AM
6738 {
6739 /* Fill in zeroth symbol and swap it out. */
6740 Elf_Internal_Sym sym;
6741 sym.st_name = 0;
6742 sym.st_value = 0;
6743 sym.st_size = 0;
6744 sym.st_info = 0;
6745 sym.st_other = 0;
6746 sym.st_shndx = SHN_UNDEF;
35fc36a8 6747 sym.st_target_internal = 0;
9ad5cbcf 6748 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6749 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM
6750 if (outbound_shndx != NULL)
6751 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6752 }
252b5132 6753
174fd7f9
RS
6754 name_local_sections
6755 = (bed->elf_backend_name_local_section_symbols
6756 && bed->elf_backend_name_local_section_symbols (abfd));
6757
079e9a2f
AM
6758 syms = bfd_get_outsymbols (abfd);
6759 for (idx = 0; idx < symcount; idx++)
252b5132 6760 {
252b5132 6761 Elf_Internal_Sym sym;
079e9a2f
AM
6762 bfd_vma value = syms[idx]->value;
6763 elf_symbol_type *type_ptr;
6764 flagword flags = syms[idx]->flags;
6765 int type;
252b5132 6766
174fd7f9
RS
6767 if (!name_local_sections
6768 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM
6769 {
6770 /* Local section symbols have no name. */
6771 sym.st_name = 0;
6772 }
6773 else
6774 {
6775 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6776 syms[idx]->name,
b34976b6 6777 TRUE, FALSE);
079e9a2f 6778 if (sym.st_name == (unsigned long) -1)
5ed6aba4
NC
6779 {
6780 _bfd_stringtab_free (stt);
6781 return FALSE;
6782 }
079e9a2f 6783 }
252b5132 6784
079e9a2f 6785 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 6786
079e9a2f
AM
6787 if ((flags & BSF_SECTION_SYM) == 0
6788 && bfd_is_com_section (syms[idx]->section))
6789 {
6790 /* ELF common symbols put the alignment into the `value' field,
6791 and the size into the `size' field. This is backwards from
6792 how BFD handles it, so reverse it here. */
6793 sym.st_size = value;
6794 if (type_ptr == NULL
6795 || type_ptr->internal_elf_sym.st_value == 0)
6796 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6797 else
6798 sym.st_value = type_ptr->internal_elf_sym.st_value;
6799 sym.st_shndx = _bfd_elf_section_from_bfd_section
6800 (abfd, syms[idx]->section);
6801 }
6802 else
6803 {
6804 asection *sec = syms[idx]->section;
cb33740c 6805 unsigned int shndx;
252b5132 6806
079e9a2f
AM
6807 if (sec->output_section)
6808 {
6809 value += sec->output_offset;
6810 sec = sec->output_section;
6811 }
589e6347 6812
079e9a2f
AM
6813 /* Don't add in the section vma for relocatable output. */
6814 if (! relocatable_p)
6815 value += sec->vma;
6816 sym.st_value = value;
6817 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6818
6819 if (bfd_is_abs_section (sec)
6820 && type_ptr != NULL
6821 && type_ptr->internal_elf_sym.st_shndx != 0)
6822 {
6823 /* This symbol is in a real ELF section which we did
6824 not create as a BFD section. Undo the mapping done
6825 by copy_private_symbol_data. */
6826 shndx = type_ptr->internal_elf_sym.st_shndx;
6827 switch (shndx)
6828 {
6829 case MAP_ONESYMTAB:
6830 shndx = elf_onesymtab (abfd);
6831 break;
6832 case MAP_DYNSYMTAB:
6833 shndx = elf_dynsymtab (abfd);
6834 break;
6835 case MAP_STRTAB:
12bd6957 6836 shndx = elf_strtab_sec (abfd);
079e9a2f
AM
6837 break;
6838 case MAP_SHSTRTAB:
12bd6957 6839 shndx = elf_shstrtab_sec (abfd);
079e9a2f 6840 break;
9ad5cbcf 6841 case MAP_SYM_SHNDX:
12bd6957 6842 shndx = elf_symtab_shndx (abfd);
9ad5cbcf 6843 break;
079e9a2f 6844 default:
15bc576a 6845 shndx = SHN_ABS;
079e9a2f
AM
6846 break;
6847 }
6848 }
6849 else
6850 {
6851 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 6852
cb33740c 6853 if (shndx == SHN_BAD)
079e9a2f
AM
6854 {
6855 asection *sec2;
6856
6857 /* Writing this would be a hell of a lot easier if
6858 we had some decent documentation on bfd, and
6859 knew what to expect of the library, and what to
6860 demand of applications. For example, it
6861 appears that `objcopy' might not set the
6862 section of a symbol to be a section that is
6863 actually in the output file. */
6864 sec2 = bfd_get_section_by_name (abfd, sec->name);
589e6347
NC
6865 if (sec2 == NULL)
6866 {
6867 _bfd_error_handler (_("\
6868Unable to find equivalent output section for symbol '%s' from section '%s'"),
6869 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6870 sec->name);
811072d8 6871 bfd_set_error (bfd_error_invalid_operation);
5ed6aba4 6872 _bfd_stringtab_free (stt);
589e6347
NC
6873 return FALSE;
6874 }
811072d8 6875
079e9a2f 6876 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
cb33740c 6877 BFD_ASSERT (shndx != SHN_BAD);
079e9a2f
AM
6878 }
6879 }
252b5132 6880
079e9a2f
AM
6881 sym.st_shndx = shndx;
6882 }
252b5132 6883
13ae64f3
JJ
6884 if ((flags & BSF_THREAD_LOCAL) != 0)
6885 type = STT_TLS;
d8045f23
NC
6886 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6887 type = STT_GNU_IFUNC;
13ae64f3 6888 else if ((flags & BSF_FUNCTION) != 0)
079e9a2f
AM
6889 type = STT_FUNC;
6890 else if ((flags & BSF_OBJECT) != 0)
6891 type = STT_OBJECT;
d9352518
DB
6892 else if ((flags & BSF_RELC) != 0)
6893 type = STT_RELC;
6894 else if ((flags & BSF_SRELC) != 0)
6895 type = STT_SRELC;
079e9a2f
AM
6896 else
6897 type = STT_NOTYPE;
252b5132 6898
13ae64f3
JJ
6899 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6900 type = STT_TLS;
6901
589e6347 6902 /* Processor-specific types. */
079e9a2f
AM
6903 if (type_ptr != NULL
6904 && bed->elf_backend_get_symbol_type)
6905 type = ((*bed->elf_backend_get_symbol_type)
6906 (&type_ptr->internal_elf_sym, type));
252b5132 6907
079e9a2f
AM
6908 if (flags & BSF_SECTION_SYM)
6909 {
6910 if (flags & BSF_GLOBAL)
6911 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6912 else
6913 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6914 }
6915 else if (bfd_is_com_section (syms[idx]->section))
0a40daed 6916 {
504b7d20 6917#ifdef USE_STT_COMMON
0a40daed
MK
6918 if (type == STT_OBJECT)
6919 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6920 else
504b7d20 6921#endif
c91e322a 6922 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
0a40daed 6923 }
079e9a2f
AM
6924 else if (bfd_is_und_section (syms[idx]->section))
6925 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6926 ? STB_WEAK
6927 : STB_GLOBAL),
6928 type);
6929 else if (flags & BSF_FILE)
6930 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6931 else
6932 {
6933 int bind = STB_LOCAL;
252b5132 6934
079e9a2f
AM
6935 if (flags & BSF_LOCAL)
6936 bind = STB_LOCAL;
3e7a7d11
NC
6937 else if (flags & BSF_GNU_UNIQUE)
6938 bind = STB_GNU_UNIQUE;
079e9a2f
AM
6939 else if (flags & BSF_WEAK)
6940 bind = STB_WEAK;
6941 else if (flags & BSF_GLOBAL)
6942 bind = STB_GLOBAL;
252b5132 6943
079e9a2f
AM
6944 sym.st_info = ELF_ST_INFO (bind, type);
6945 }
252b5132 6946
079e9a2f 6947 if (type_ptr != NULL)
35fc36a8
RS
6948 {
6949 sym.st_other = type_ptr->internal_elf_sym.st_other;
6950 sym.st_target_internal
6951 = type_ptr->internal_elf_sym.st_target_internal;
6952 }
079e9a2f 6953 else
35fc36a8
RS
6954 {
6955 sym.st_other = 0;
6956 sym.st_target_internal = 0;
6957 }
252b5132 6958
9ad5cbcf 6959 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6960 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM
6961 if (outbound_shndx != NULL)
6962 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6963 }
252b5132 6964
079e9a2f
AM
6965 *sttp = stt;
6966 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6967 symstrtab_hdr->sh_type = SHT_STRTAB;
252b5132 6968
079e9a2f
AM
6969 symstrtab_hdr->sh_flags = 0;
6970 symstrtab_hdr->sh_addr = 0;
6971 symstrtab_hdr->sh_entsize = 0;
6972 symstrtab_hdr->sh_link = 0;
6973 symstrtab_hdr->sh_info = 0;
6974 symstrtab_hdr->sh_addralign = 1;
252b5132 6975
b34976b6 6976 return TRUE;
252b5132
RH
6977}
6978
6979/* Return the number of bytes required to hold the symtab vector.
6980
6981 Note that we base it on the count plus 1, since we will null terminate
6982 the vector allocated based on this size. However, the ELF symbol table
6983 always has a dummy entry as symbol #0, so it ends up even. */
6984
6985long
217aa764 6986_bfd_elf_get_symtab_upper_bound (bfd *abfd)
252b5132
RH
6987{
6988 long symcount;
6989 long symtab_size;
6990 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6991
6992 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM
6993 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6994 if (symcount > 0)
6995 symtab_size -= sizeof (asymbol *);
252b5132
RH
6996
6997 return symtab_size;
6998}
6999
7000long
217aa764 7001_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
252b5132
RH
7002{
7003 long symcount;
7004 long symtab_size;
7005 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
7006
7007 if (elf_dynsymtab (abfd) == 0)
7008 {
7009 bfd_set_error (bfd_error_invalid_operation);
7010 return -1;
7011 }
7012
7013 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM
7014 symtab_size = (symcount + 1) * (sizeof (asymbol *));
7015 if (symcount > 0)
7016 symtab_size -= sizeof (asymbol *);
252b5132
RH
7017
7018 return symtab_size;
7019}
7020
7021long
217aa764
AM
7022_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
7023 sec_ptr asect)
252b5132
RH
7024{
7025 return (asect->reloc_count + 1) * sizeof (arelent *);
7026}
7027
7028/* Canonicalize the relocs. */
7029
7030long
217aa764
AM
7031_bfd_elf_canonicalize_reloc (bfd *abfd,
7032 sec_ptr section,
7033 arelent **relptr,
7034 asymbol **symbols)
252b5132
RH
7035{
7036 arelent *tblptr;
7037 unsigned int i;
9c5bfbb7 7038 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 7039
b34976b6 7040 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
252b5132
RH
7041 return -1;
7042
7043 tblptr = section->relocation;
7044 for (i = 0; i < section->reloc_count; i++)
7045 *relptr++ = tblptr++;
7046
7047 *relptr = NULL;
7048
7049 return section->reloc_count;
7050}
7051
7052long
6cee3f79 7053_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
252b5132 7054{
9c5bfbb7 7055 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 7056 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
252b5132
RH
7057
7058 if (symcount >= 0)
7059 bfd_get_symcount (abfd) = symcount;
7060 return symcount;
7061}
7062
7063long
217aa764
AM
7064_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
7065 asymbol **allocation)
252b5132 7066{
9c5bfbb7 7067 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 7068 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
1f70368c
DJ
7069
7070 if (symcount >= 0)
7071 bfd_get_dynamic_symcount (abfd) = symcount;
7072 return symcount;
252b5132
RH
7073}
7074
8615f3f2
AM
7075/* Return the size required for the dynamic reloc entries. Any loadable
7076 section that was actually installed in the BFD, and has type SHT_REL
7077 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
7078 dynamic reloc section. */
252b5132
RH
7079
7080long
217aa764 7081_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
252b5132
RH
7082{
7083 long ret;
7084 asection *s;
7085
7086 if (elf_dynsymtab (abfd) == 0)
7087 {
7088 bfd_set_error (bfd_error_invalid_operation);
7089 return -1;
7090 }
7091
7092 ret = sizeof (arelent *);
7093 for (s = abfd->sections; s != NULL; s = s->next)
266b05cf 7094 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH
7095 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7096 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
eea6121a 7097 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
252b5132
RH
7098 * sizeof (arelent *));
7099
7100 return ret;
7101}
7102
8615f3f2
AM
7103/* Canonicalize the dynamic relocation entries. Note that we return the
7104 dynamic relocations as a single block, although they are actually
7105 associated with particular sections; the interface, which was
7106 designed for SunOS style shared libraries, expects that there is only
7107 one set of dynamic relocs. Any loadable section that was actually
7108 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
7109 dynamic symbol table, is considered to be a dynamic reloc section. */
252b5132
RH
7110
7111long
217aa764
AM
7112_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
7113 arelent **storage,
7114 asymbol **syms)
252b5132 7115{
217aa764 7116 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
252b5132
RH
7117 asection *s;
7118 long ret;
7119
7120 if (elf_dynsymtab (abfd) == 0)
7121 {
7122 bfd_set_error (bfd_error_invalid_operation);
7123 return -1;
7124 }
7125
7126 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
7127 ret = 0;
7128 for (s = abfd->sections; s != NULL; s = s->next)
7129 {
266b05cf 7130 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH
7131 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
7132 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
7133 {
7134 arelent *p;
7135 long count, i;
7136
b34976b6 7137 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
252b5132 7138 return -1;
eea6121a 7139 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
252b5132
RH
7140 p = s->relocation;
7141 for (i = 0; i < count; i++)
7142 *storage++ = p++;
7143 ret += count;
7144 }
7145 }
7146
7147 *storage = NULL;
7148
7149 return ret;
7150}
7151\f
7152/* Read in the version information. */
7153
b34976b6 7154bfd_boolean
fc0e6df6 7155_bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
252b5132
RH
7156{
7157 bfd_byte *contents = NULL;
fc0e6df6
PB
7158 unsigned int freeidx = 0;
7159
7160 if (elf_dynverref (abfd) != 0)
7161 {
7162 Elf_Internal_Shdr *hdr;
7163 Elf_External_Verneed *everneed;
7164 Elf_Internal_Verneed *iverneed;
7165 unsigned int i;
d0fb9a8d 7166 bfd_byte *contents_end;
fc0e6df6
PB
7167
7168 hdr = &elf_tdata (abfd)->dynverref_hdr;
7169
a50b1753
NC
7170 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
7171 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
fc0e6df6
PB
7172 if (elf_tdata (abfd)->verref == NULL)
7173 goto error_return;
7174
7175 elf_tdata (abfd)->cverrefs = hdr->sh_info;
7176
a50b1753 7177 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
fc0e6df6 7178 if (contents == NULL)
d0fb9a8d
JJ
7179 {
7180error_return_verref:
7181 elf_tdata (abfd)->verref = NULL;
7182 elf_tdata (abfd)->cverrefs = 0;
7183 goto error_return;
7184 }
fc0e6df6
PB
7185 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7186 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
d0fb9a8d 7187 goto error_return_verref;
fc0e6df6 7188
d0fb9a8d
JJ
7189 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
7190 goto error_return_verref;
7191
7192 BFD_ASSERT (sizeof (Elf_External_Verneed)
7193 == sizeof (Elf_External_Vernaux));
7194 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
fc0e6df6
PB
7195 everneed = (Elf_External_Verneed *) contents;
7196 iverneed = elf_tdata (abfd)->verref;
7197 for (i = 0; i < hdr->sh_info; i++, iverneed++)
7198 {
7199 Elf_External_Vernaux *evernaux;
7200 Elf_Internal_Vernaux *ivernaux;
7201 unsigned int j;
7202
7203 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7204
7205 iverneed->vn_bfd = abfd;
7206
7207 iverneed->vn_filename =
7208 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7209 iverneed->vn_file);
7210 if (iverneed->vn_filename == NULL)
d0fb9a8d 7211 goto error_return_verref;
fc0e6df6 7212
d0fb9a8d
JJ
7213 if (iverneed->vn_cnt == 0)
7214 iverneed->vn_auxptr = NULL;
7215 else
7216 {
a50b1753
NC
7217 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7218 bfd_alloc2 (abfd, iverneed->vn_cnt,
7219 sizeof (Elf_Internal_Vernaux));
d0fb9a8d
JJ
7220 if (iverneed->vn_auxptr == NULL)
7221 goto error_return_verref;
7222 }
7223
7224 if (iverneed->vn_aux
7225 > (size_t) (contents_end - (bfd_byte *) everneed))
7226 goto error_return_verref;
fc0e6df6
PB
7227
7228 evernaux = ((Elf_External_Vernaux *)
7229 ((bfd_byte *) everneed + iverneed->vn_aux));
7230 ivernaux = iverneed->vn_auxptr;
7231 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
7232 {
7233 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
7234
7235 ivernaux->vna_nodename =
7236 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7237 ivernaux->vna_name);
7238 if (ivernaux->vna_nodename == NULL)
d0fb9a8d 7239 goto error_return_verref;
fc0e6df6
PB
7240
7241 if (j + 1 < iverneed->vn_cnt)
7242 ivernaux->vna_nextptr = ivernaux + 1;
7243 else
7244 ivernaux->vna_nextptr = NULL;
7245
d0fb9a8d
JJ
7246 if (ivernaux->vna_next
7247 > (size_t) (contents_end - (bfd_byte *) evernaux))
7248 goto error_return_verref;
7249
fc0e6df6
PB
7250 evernaux = ((Elf_External_Vernaux *)
7251 ((bfd_byte *) evernaux + ivernaux->vna_next));
7252
7253 if (ivernaux->vna_other > freeidx)
7254 freeidx = ivernaux->vna_other;
7255 }
7256
7257 if (i + 1 < hdr->sh_info)
7258 iverneed->vn_nextref = iverneed + 1;
7259 else
7260 iverneed->vn_nextref = NULL;
7261
d0fb9a8d
JJ
7262 if (iverneed->vn_next
7263 > (size_t) (contents_end - (bfd_byte *) everneed))
7264 goto error_return_verref;
7265
fc0e6df6
PB
7266 everneed = ((Elf_External_Verneed *)
7267 ((bfd_byte *) everneed + iverneed->vn_next));
7268 }
7269
7270 free (contents);
7271 contents = NULL;
7272 }
252b5132
RH
7273
7274 if (elf_dynverdef (abfd) != 0)
7275 {
7276 Elf_Internal_Shdr *hdr;
7277 Elf_External_Verdef *everdef;
7278 Elf_Internal_Verdef *iverdef;
f631889e
UD
7279 Elf_Internal_Verdef *iverdefarr;
7280 Elf_Internal_Verdef iverdefmem;
252b5132 7281 unsigned int i;
062e2358 7282 unsigned int maxidx;
d0fb9a8d 7283 bfd_byte *contents_end_def, *contents_end_aux;
252b5132
RH
7284
7285 hdr = &elf_tdata (abfd)->dynverdef_hdr;
7286
a50b1753 7287 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
252b5132
RH
7288 if (contents == NULL)
7289 goto error_return;
7290 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 7291 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
252b5132
RH
7292 goto error_return;
7293
d0fb9a8d
JJ
7294 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
7295 goto error_return;
7296
7297 BFD_ASSERT (sizeof (Elf_External_Verdef)
7298 >= sizeof (Elf_External_Verdaux));
7299 contents_end_def = contents + hdr->sh_size
7300 - sizeof (Elf_External_Verdef);
7301 contents_end_aux = contents + hdr->sh_size
7302 - sizeof (Elf_External_Verdaux);
7303
f631889e
UD
7304 /* We know the number of entries in the section but not the maximum
7305 index. Therefore we have to run through all entries and find
7306 the maximum. */
252b5132 7307 everdef = (Elf_External_Verdef *) contents;
f631889e
UD
7308 maxidx = 0;
7309 for (i = 0; i < hdr->sh_info; ++i)
7310 {
7311 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7312
062e2358
AM
7313 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
7314 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
f631889e 7315
d0fb9a8d
JJ
7316 if (iverdefmem.vd_next
7317 > (size_t) (contents_end_def - (bfd_byte *) everdef))
7318 goto error_return;
7319
f631889e
UD
7320 everdef = ((Elf_External_Verdef *)
7321 ((bfd_byte *) everdef + iverdefmem.vd_next));
7322 }
7323
fc0e6df6
PB
7324 if (default_imported_symver)
7325 {
7326 if (freeidx > maxidx)
7327 maxidx = ++freeidx;
7328 else
7329 freeidx = ++maxidx;
7330 }
a50b1753
NC
7331 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7332 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
f631889e
UD
7333 if (elf_tdata (abfd)->verdef == NULL)
7334 goto error_return;
7335
7336 elf_tdata (abfd)->cverdefs = maxidx;
7337
7338 everdef = (Elf_External_Verdef *) contents;
7339 iverdefarr = elf_tdata (abfd)->verdef;
7340 for (i = 0; i < hdr->sh_info; i++)
252b5132
RH
7341 {
7342 Elf_External_Verdaux *everdaux;
7343 Elf_Internal_Verdaux *iverdaux;
7344 unsigned int j;
7345
f631889e
UD
7346 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7347
d0fb9a8d
JJ
7348 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
7349 {
7350error_return_verdef:
7351 elf_tdata (abfd)->verdef = NULL;
7352 elf_tdata (abfd)->cverdefs = 0;
7353 goto error_return;
7354 }
7355
f631889e
UD
7356 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
7357 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
252b5132
RH
7358
7359 iverdef->vd_bfd = abfd;
7360
d0fb9a8d
JJ
7361 if (iverdef->vd_cnt == 0)
7362 iverdef->vd_auxptr = NULL;
7363 else
7364 {
a50b1753
NC
7365 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7366 bfd_alloc2 (abfd, iverdef->vd_cnt,
7367 sizeof (Elf_Internal_Verdaux));
d0fb9a8d
JJ
7368 if (iverdef->vd_auxptr == NULL)
7369 goto error_return_verdef;
7370 }
7371
7372 if (iverdef->vd_aux
7373 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
7374 goto error_return_verdef;
252b5132
RH
7375
7376 everdaux = ((Elf_External_Verdaux *)
7377 ((bfd_byte *) everdef + iverdef->vd_aux));
7378 iverdaux = iverdef->vd_auxptr;
7379 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
7380 {
7381 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
7382
7383 iverdaux->vda_nodename =
7384 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7385 iverdaux->vda_name);
7386 if (iverdaux->vda_nodename == NULL)
d0fb9a8d 7387 goto error_return_verdef;
252b5132
RH
7388
7389 if (j + 1 < iverdef->vd_cnt)
7390 iverdaux->vda_nextptr = iverdaux + 1;
7391 else
7392 iverdaux->vda_nextptr = NULL;
7393
d0fb9a8d
JJ
7394 if (iverdaux->vda_next
7395 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7396 goto error_return_verdef;
7397
252b5132
RH
7398 everdaux = ((Elf_External_Verdaux *)
7399 ((bfd_byte *) everdaux + iverdaux->vda_next));
7400 }
7401
d0fb9a8d
JJ
7402 if (iverdef->vd_cnt)
7403 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
252b5132 7404
d0fb9a8d 7405 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
252b5132
RH
7406 iverdef->vd_nextdef = iverdef + 1;
7407 else
7408 iverdef->vd_nextdef = NULL;
7409
7410 everdef = ((Elf_External_Verdef *)
7411 ((bfd_byte *) everdef + iverdef->vd_next));
7412 }
7413
7414 free (contents);
7415 contents = NULL;
7416 }
fc0e6df6 7417 else if (default_imported_symver)
252b5132 7418 {
fc0e6df6
PB
7419 if (freeidx < 3)
7420 freeidx = 3;
7421 else
7422 freeidx++;
252b5132 7423
a50b1753
NC
7424 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7425 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
fc0e6df6 7426 if (elf_tdata (abfd)->verdef == NULL)
252b5132
RH
7427 goto error_return;
7428
fc0e6df6
PB
7429 elf_tdata (abfd)->cverdefs = freeidx;
7430 }
252b5132 7431
fc0e6df6
PB
7432 /* Create a default version based on the soname. */
7433 if (default_imported_symver)
7434 {
7435 Elf_Internal_Verdef *iverdef;
7436 Elf_Internal_Verdaux *iverdaux;
252b5132 7437
5bb3703f 7438 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];
252b5132 7439
fc0e6df6
PB
7440 iverdef->vd_version = VER_DEF_CURRENT;
7441 iverdef->vd_flags = 0;
7442 iverdef->vd_ndx = freeidx;
7443 iverdef->vd_cnt = 1;
252b5132 7444
fc0e6df6 7445 iverdef->vd_bfd = abfd;
252b5132 7446
fc0e6df6
PB
7447 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7448 if (iverdef->vd_nodename == NULL)
d0fb9a8d 7449 goto error_return_verdef;
fc0e6df6 7450 iverdef->vd_nextdef = NULL;
a50b1753
NC
7451 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7452 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
d0fb9a8d
JJ
7453 if (iverdef->vd_auxptr == NULL)
7454 goto error_return_verdef;
252b5132 7455
fc0e6df6
PB
7456 iverdaux = iverdef->vd_auxptr;
7457 iverdaux->vda_nodename = iverdef->vd_nodename;
7458 iverdaux->vda_nextptr = NULL;
252b5132
RH
7459 }
7460
b34976b6 7461 return TRUE;
252b5132
RH
7462
7463 error_return:
5ed6aba4 7464 if (contents != NULL)
252b5132 7465 free (contents);
b34976b6 7466 return FALSE;
252b5132
RH
7467}
7468\f
7469asymbol *
217aa764 7470_bfd_elf_make_empty_symbol (bfd *abfd)
252b5132
RH
7471{
7472 elf_symbol_type *newsym;
dc810e39 7473 bfd_size_type amt = sizeof (elf_symbol_type);
252b5132 7474
a50b1753 7475 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
252b5132
RH
7476 if (!newsym)
7477 return NULL;
7478 else
7479 {
7480 newsym->symbol.the_bfd = abfd;
7481 return &newsym->symbol;
7482 }
7483}
7484
7485void
217aa764
AM
7486_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7487 asymbol *symbol,
7488 symbol_info *ret)
252b5132
RH
7489{
7490 bfd_symbol_info (symbol, ret);
7491}
7492
7493/* Return whether a symbol name implies a local symbol. Most targets
7494 use this function for the is_local_label_name entry point, but some
7495 override it. */
7496
b34976b6 7497bfd_boolean
217aa764
AM
7498_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7499 const char *name)
252b5132
RH
7500{
7501 /* Normal local symbols start with ``.L''. */
7502 if (name[0] == '.' && name[1] == 'L')
b34976b6 7503 return TRUE;
252b5132
RH
7504
7505 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7506 DWARF debugging symbols starting with ``..''. */
7507 if (name[0] == '.' && name[1] == '.')
b34976b6 7508 return TRUE;
252b5132
RH
7509
7510 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7511 emitting DWARF debugging output. I suspect this is actually a
7512 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7513 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7514 underscore to be emitted on some ELF targets). For ease of use,
7515 we treat such symbols as local. */
7516 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
b34976b6 7517 return TRUE;
252b5132 7518
b34976b6 7519 return FALSE;
252b5132
RH
7520}
7521
7522alent *
217aa764
AM
7523_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7524 asymbol *symbol ATTRIBUTE_UNUSED)
252b5132
RH
7525{
7526 abort ();
7527 return NULL;
7528}
7529
b34976b6 7530bfd_boolean
217aa764
AM
7531_bfd_elf_set_arch_mach (bfd *abfd,
7532 enum bfd_architecture arch,
7533 unsigned long machine)
252b5132
RH
7534{
7535 /* If this isn't the right architecture for this backend, and this
7536 isn't the generic backend, fail. */
7537 if (arch != get_elf_backend_data (abfd)->arch
7538 && arch != bfd_arch_unknown
7539 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
b34976b6 7540 return FALSE;
252b5132
RH
7541
7542 return bfd_default_set_arch_mach (abfd, arch, machine);
7543}
7544
d1fad7c6
NC
7545/* Find the function to a particular section and offset,
7546 for error reporting. */
252b5132 7547
b34976b6 7548static bfd_boolean
b9d678e0 7549elf_find_function (bfd *abfd,
217aa764
AM
7550 asection *section,
7551 asymbol **symbols,
7552 bfd_vma offset,
7553 const char **filename_ptr,
7554 const char **functionname_ptr)
252b5132 7555{
619a703e
AM
7556 struct elf_find_function_cache
7557 {
7558 asection *last_section;
7559 asymbol *func;
7560 const char *filename;
7561 bfd_size_type func_size;
7562 } *cache;
252b5132 7563
a06c7d5a
NC
7564 if (symbols == NULL)
7565 return FALSE;
7566
619a703e
AM
7567 cache = elf_tdata (abfd)->elf_find_function_cache;
7568 if (cache == NULL)
7569 {
7570 cache = bfd_zalloc (abfd, sizeof (*cache));
7571 elf_tdata (abfd)->elf_find_function_cache = cache;
7572 if (cache == NULL)
7573 return FALSE;
7574 }
7575 if (cache->last_section != section
7576 || cache->func == NULL
7577 || offset < cache->func->value
7578 || offset >= cache->func->value + cache->func_size)
aef36ac1
AM
7579 {
7580 asymbol *file;
7581 bfd_vma low_func;
7582 asymbol **p;
7583 /* ??? Given multiple file symbols, it is impossible to reliably
7584 choose the right file name for global symbols. File symbols are
7585 local symbols, and thus all file symbols must sort before any
7586 global symbols. The ELF spec may be interpreted to say that a
7587 file symbol must sort before other local symbols, but currently
7588 ld -r doesn't do this. So, for ld -r output, it is possible to
7589 make a better choice of file name for local symbols by ignoring
7590 file symbols appearing after a given local symbol. */
7591 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
7592 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7593
aef36ac1
AM
7594 file = NULL;
7595 low_func = 0;
7596 state = nothing_seen;
619a703e
AM
7597 cache->filename = NULL;
7598 cache->func = NULL;
7599 cache->func_size = 0;
7600 cache->last_section = section;
aef36ac1
AM
7601
7602 for (p = symbols; *p != NULL; p++)
7603 {
7604 asymbol *sym = *p;
7605 bfd_vma code_off;
7606 bfd_size_type size;
7607
7608 if ((sym->flags & BSF_FILE) != 0)
7609 {
7610 file = sym;
7611 if (state == symbol_seen)
7612 state = file_after_symbol_seen;
7613 continue;
7614 }
ff9e0f5b 7615
aef36ac1
AM
7616 size = bed->maybe_function_sym (sym, section, &code_off);
7617 if (size != 0
7618 && code_off <= offset
7619 && (code_off > low_func
7620 || (code_off == low_func
619a703e 7621 && size > cache->func_size)))
aef36ac1 7622 {
619a703e
AM
7623 cache->func = sym;
7624 cache->func_size = size;
7625 cache->filename = NULL;
aef36ac1 7626 low_func = code_off;
aef36ac1
AM
7627 if (file != NULL
7628 && ((sym->flags & BSF_LOCAL) != 0
7629 || state != file_after_symbol_seen))
619a703e 7630 cache->filename = bfd_asymbol_name (file);
aef36ac1
AM
7631 }
7632 if (state == nothing_seen)
7633 state = symbol_seen;
252b5132
RH
7634 }
7635 }
7636
619a703e 7637 if (cache->func == NULL)
b34976b6 7638 return FALSE;
252b5132 7639
d1fad7c6 7640 if (filename_ptr)
619a703e 7641 *filename_ptr = cache->filename;
d1fad7c6 7642 if (functionname_ptr)
619a703e 7643 *functionname_ptr = bfd_asymbol_name (cache->func);
d1fad7c6 7644
b34976b6 7645 return TRUE;
d1fad7c6
NC
7646}
7647
7648/* Find the nearest line to a particular section and offset,
7649 for error reporting. */
7650
b34976b6 7651bfd_boolean
217aa764
AM
7652_bfd_elf_find_nearest_line (bfd *abfd,
7653 asection *section,
7654 asymbol **symbols,
7655 bfd_vma offset,
7656 const char **filename_ptr,
7657 const char **functionname_ptr,
7658 unsigned int *line_ptr)
9b8d1a36
CC
7659{
7660 return _bfd_elf_find_nearest_line_discriminator (abfd, section, symbols,
7661 offset, filename_ptr,
7662 functionname_ptr,
7663 line_ptr,
7664 NULL);
7665}
7666
7667bfd_boolean
7668_bfd_elf_find_nearest_line_discriminator (bfd *abfd,
7669 asection *section,
7670 asymbol **symbols,
7671 bfd_vma offset,
7672 const char **filename_ptr,
7673 const char **functionname_ptr,
7674 unsigned int *line_ptr,
7675 unsigned int *discriminator_ptr)
d1fad7c6 7676{
b34976b6 7677 bfd_boolean found;
d1fad7c6
NC
7678
7679 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM
7680 filename_ptr, functionname_ptr,
7681 line_ptr))
d1fad7c6
NC
7682 {
7683 if (!*functionname_ptr)
4e8a9624
AM
7684 elf_find_function (abfd, section, symbols, offset,
7685 *filename_ptr ? NULL : filename_ptr,
7686 functionname_ptr);
7687
b34976b6 7688 return TRUE;
d1fad7c6
NC
7689 }
7690
fc28f9aa
TG
7691 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
7692 section, symbols, offset,
4e8a9624 7693 filename_ptr, functionname_ptr,
9b8d1a36 7694 line_ptr, discriminator_ptr, 0,
4e8a9624 7695 &elf_tdata (abfd)->dwarf2_find_line_info))
d1fad7c6
NC
7696 {
7697 if (!*functionname_ptr)
4e8a9624
AM
7698 elf_find_function (abfd, section, symbols, offset,
7699 *filename_ptr ? NULL : filename_ptr,
7700 functionname_ptr);
7701
b34976b6 7702 return TRUE;
d1fad7c6
NC
7703 }
7704
7705 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM
7706 &found, filename_ptr,
7707 functionname_ptr, line_ptr,
7708 &elf_tdata (abfd)->line_info))
b34976b6 7709 return FALSE;
dc43ada5 7710 if (found && (*functionname_ptr || *line_ptr))
b34976b6 7711 return TRUE;
d1fad7c6
NC
7712
7713 if (symbols == NULL)
b34976b6 7714 return FALSE;
d1fad7c6
NC
7715
7716 if (! elf_find_function (abfd, section, symbols, offset,
4e8a9624 7717 filename_ptr, functionname_ptr))
b34976b6 7718 return FALSE;
d1fad7c6 7719
252b5132 7720 *line_ptr = 0;
b34976b6 7721 return TRUE;
252b5132
RH
7722}
7723
5420f73d
L
7724/* Find the line for a symbol. */
7725
7726bfd_boolean
7727_bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7728 const char **filename_ptr, unsigned int *line_ptr)
9b8d1a36
CC
7729{
7730 return _bfd_elf_find_line_discriminator (abfd, symbols, symbol,
7731 filename_ptr, line_ptr,
7732 NULL);
7733}
7734
7735bfd_boolean
7736_bfd_elf_find_line_discriminator (bfd *abfd, asymbol **symbols, asymbol *symbol,
7737 const char **filename_ptr,
7738 unsigned int *line_ptr,
7739 unsigned int *discriminator_ptr)
5420f73d
L
7740{
7741 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
9b8d1a36 7742 filename_ptr, line_ptr, discriminator_ptr, 0,
5420f73d
L
7743 &elf_tdata (abfd)->dwarf2_find_line_info);
7744}
7745
4ab527b0
FF
7746/* After a call to bfd_find_nearest_line, successive calls to
7747 bfd_find_inliner_info can be used to get source information about
7748 each level of function inlining that terminated at the address
7749 passed to bfd_find_nearest_line. Currently this is only supported
7750 for DWARF2 with appropriate DWARF3 extensions. */
7751
7752bfd_boolean
7753_bfd_elf_find_inliner_info (bfd *abfd,
7754 const char **filename_ptr,
7755 const char **functionname_ptr,
7756 unsigned int *line_ptr)
7757{
7758 bfd_boolean found;
7759 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7760 functionname_ptr, line_ptr,
7761 & elf_tdata (abfd)->dwarf2_find_line_info);
7762 return found;
7763}
7764
252b5132 7765int
a6b96beb 7766_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
252b5132 7767{
8ded5a0f
AM
7768 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7769 int ret = bed->s->sizeof_ehdr;
252b5132 7770
a6b96beb 7771 if (!info->relocatable)
8ded5a0f 7772 {
12bd6957 7773 bfd_size_type phdr_size = elf_program_header_size (abfd);
8ded5a0f 7774
62d7a5f6
AM
7775 if (phdr_size == (bfd_size_type) -1)
7776 {
7777 struct elf_segment_map *m;
7778
7779 phdr_size = 0;
12bd6957 7780 for (m = elf_seg_map (abfd); m != NULL; m = m->next)
62d7a5f6 7781 phdr_size += bed->s->sizeof_phdr;
8ded5a0f 7782
62d7a5f6
AM
7783 if (phdr_size == 0)
7784 phdr_size = get_program_header_size (abfd, info);
7785 }
8ded5a0f 7786
12bd6957 7787 elf_program_header_size (abfd) = phdr_size;
8ded5a0f
AM
7788 ret += phdr_size;
7789 }
7790
252b5132
RH
7791 return ret;
7792}
7793
b34976b6 7794bfd_boolean
217aa764
AM
7795_bfd_elf_set_section_contents (bfd *abfd,
7796 sec_ptr section,
0f867abe 7797 const void *location,
217aa764
AM
7798 file_ptr offset,
7799 bfd_size_type count)
252b5132
RH
7800{
7801 Elf_Internal_Shdr *hdr;
dc810e39 7802 bfd_signed_vma pos;
252b5132
RH
7803
7804 if (! abfd->output_has_begun
217aa764 7805 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 7806 return FALSE;
252b5132
RH
7807
7808 hdr = &elf_section_data (section)->this_hdr;
dc810e39
AM
7809 pos = hdr->sh_offset + offset;
7810 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7811 || bfd_bwrite (location, count, abfd) != count)
b34976b6 7812 return FALSE;
252b5132 7813
b34976b6 7814 return TRUE;
252b5132
RH
7815}
7816
7817void
217aa764
AM
7818_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7819 arelent *cache_ptr ATTRIBUTE_UNUSED,
7820 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH
7821{
7822 abort ();
7823}
7824
252b5132
RH
7825/* Try to convert a non-ELF reloc into an ELF one. */
7826
b34976b6 7827bfd_boolean
217aa764 7828_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 7829{
c044fabd 7830 /* Check whether we really have an ELF howto. */
252b5132
RH
7831
7832 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7833 {
7834 bfd_reloc_code_real_type code;
7835 reloc_howto_type *howto;
7836
7837 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 7838 equivalent ELF reloc. */
252b5132
RH
7839
7840 if (areloc->howto->pc_relative)
7841 {
7842 switch (areloc->howto->bitsize)
7843 {
7844 case 8:
7845 code = BFD_RELOC_8_PCREL;
7846 break;
7847 case 12:
7848 code = BFD_RELOC_12_PCREL;
7849 break;
7850 case 16:
7851 code = BFD_RELOC_16_PCREL;
7852 break;
7853 case 24:
7854 code = BFD_RELOC_24_PCREL;
7855 break;
7856 case 32:
7857 code = BFD_RELOC_32_PCREL;
7858 break;
7859 case 64:
7860 code = BFD_RELOC_64_PCREL;
7861 break;
7862 default:
7863 goto fail;
7864 }
7865
7866 howto = bfd_reloc_type_lookup (abfd, code);
7867
7868 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7869 {
7870 if (howto->pcrel_offset)
7871 areloc->addend += areloc->address;
7872 else
7873 areloc->addend -= areloc->address; /* addend is unsigned!! */
7874 }
7875 }
7876 else
7877 {
7878 switch (areloc->howto->bitsize)
7879 {
7880 case 8:
7881 code = BFD_RELOC_8;
7882 break;
7883 case 14:
7884 code = BFD_RELOC_14;
7885 break;
7886 case 16:
7887 code = BFD_RELOC_16;
7888 break;
7889 case 26:
7890 code = BFD_RELOC_26;
7891 break;
7892 case 32:
7893 code = BFD_RELOC_32;
7894 break;
7895 case 64:
7896 code = BFD_RELOC_64;
7897 break;
7898 default:
7899 goto fail;
7900 }
7901
7902 howto = bfd_reloc_type_lookup (abfd, code);
7903 }
7904
7905 if (howto)
7906 areloc->howto = howto;
7907 else
7908 goto fail;
7909 }
7910
b34976b6 7911 return TRUE;
252b5132
RH
7912
7913 fail:
7914 (*_bfd_error_handler)
d003868e
AM
7915 (_("%B: unsupported relocation type %s"),
7916 abfd, areloc->howto->name);
252b5132 7917 bfd_set_error (bfd_error_bad_value);
b34976b6 7918 return FALSE;
252b5132
RH
7919}
7920
b34976b6 7921bfd_boolean
217aa764 7922_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132 7923{
d9071b0c
TG
7924 struct elf_obj_tdata *tdata = elf_tdata (abfd);
7925 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
252b5132 7926 {
c0355132 7927 if (elf_tdata (abfd)->o != NULL && elf_shstrtab (abfd) != NULL)
2b0f7ef9 7928 _bfd_elf_strtab_free (elf_shstrtab (abfd));
d9071b0c 7929 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
252b5132
RH
7930 }
7931
7932 return _bfd_generic_close_and_cleanup (abfd);
7933}
7934
7935/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7936 in the relocation's offset. Thus we cannot allow any sort of sanity
7937 range-checking to interfere. There is nothing else to do in processing
7938 this reloc. */
7939
7940bfd_reloc_status_type
217aa764
AM
7941_bfd_elf_rel_vtable_reloc_fn
7942 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 7943 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM
7944 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7945 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH
7946{
7947 return bfd_reloc_ok;
7948}
252b5132
RH
7949\f
7950/* Elf core file support. Much of this only works on native
7951 toolchains, since we rely on knowing the
7952 machine-dependent procfs structure in order to pick
c044fabd 7953 out details about the corefile. */
252b5132
RH
7954
7955#ifdef HAVE_SYS_PROCFS_H
16231b7b
DG
7956/* Needed for new procfs interface on sparc-solaris. */
7957# define _STRUCTURED_PROC 1
252b5132
RH
7958# include <sys/procfs.h>
7959#endif
7960
261b8d08
PA
7961/* Return a PID that identifies a "thread" for threaded cores, or the
7962 PID of the main process for non-threaded cores. */
252b5132
RH
7963
7964static int
217aa764 7965elfcore_make_pid (bfd *abfd)
252b5132 7966{
261b8d08
PA
7967 int pid;
7968
228e534f 7969 pid = elf_tdata (abfd)->core->lwpid;
261b8d08 7970 if (pid == 0)
228e534f 7971 pid = elf_tdata (abfd)->core->pid;
261b8d08
PA
7972
7973 return pid;
252b5132
RH
7974}
7975
252b5132
RH
7976/* If there isn't a section called NAME, make one, using
7977 data from SECT. Note, this function will generate a
7978 reference to NAME, so you shouldn't deallocate or
c044fabd 7979 overwrite it. */
252b5132 7980
b34976b6 7981static bfd_boolean
217aa764 7982elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 7983{
c044fabd 7984 asection *sect2;
252b5132
RH
7985
7986 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 7987 return TRUE;
252b5132 7988
117ed4f8 7989 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
252b5132 7990 if (sect2 == NULL)
b34976b6 7991 return FALSE;
252b5132 7992
eea6121a 7993 sect2->size = sect->size;
252b5132 7994 sect2->filepos = sect->filepos;
252b5132 7995 sect2->alignment_power = sect->alignment_power;
b34976b6 7996 return TRUE;
252b5132
RH
7997}
7998
bb0082d6
AM
7999/* Create a pseudosection containing SIZE bytes at FILEPOS. This
8000 actually creates up to two pseudosections:
8001 - For the single-threaded case, a section named NAME, unless
8002 such a section already exists.
8003 - For the multi-threaded case, a section named "NAME/PID", where
8004 PID is elfcore_make_pid (abfd).
8005 Both pseudosections have identical contents. */
b34976b6 8006bfd_boolean
217aa764
AM
8007_bfd_elfcore_make_pseudosection (bfd *abfd,
8008 char *name,
8009 size_t size,
8010 ufile_ptr filepos)
bb0082d6
AM
8011{
8012 char buf[100];
8013 char *threaded_name;
d4c88bbb 8014 size_t len;
bb0082d6
AM
8015 asection *sect;
8016
8017 /* Build the section name. */
8018
8019 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 8020 len = strlen (buf) + 1;
a50b1753 8021 threaded_name = (char *) bfd_alloc (abfd, len);
bb0082d6 8022 if (threaded_name == NULL)
b34976b6 8023 return FALSE;
d4c88bbb 8024 memcpy (threaded_name, buf, len);
bb0082d6 8025
117ed4f8
AM
8026 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
8027 SEC_HAS_CONTENTS);
bb0082d6 8028 if (sect == NULL)
b34976b6 8029 return FALSE;
eea6121a 8030 sect->size = size;
bb0082d6 8031 sect->filepos = filepos;
bb0082d6
AM
8032 sect->alignment_power = 2;
8033
936e320b 8034 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM
8035}
8036
252b5132 8037/* prstatus_t exists on:
4a938328 8038 solaris 2.5+
252b5132
RH
8039 linux 2.[01] + glibc
8040 unixware 4.2
8041*/
8042
8043#if defined (HAVE_PRSTATUS_T)
a7b97311 8044
b34976b6 8045static bfd_boolean
217aa764 8046elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 8047{
eea6121a 8048 size_t size;
7ee38065 8049 int offset;
252b5132 8050
4a938328
MS
8051 if (note->descsz == sizeof (prstatus_t))
8052 {
8053 prstatus_t prstat;
252b5132 8054
eea6121a 8055 size = sizeof (prstat.pr_reg);
7ee38065 8056 offset = offsetof (prstatus_t, pr_reg);
4a938328 8057 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 8058
fa49d224
NC
8059 /* Do not overwrite the core signal if it
8060 has already been set by another thread. */
228e534f
AM
8061 if (elf_tdata (abfd)->core->signal == 0)
8062 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
8063 if (elf_tdata (abfd)->core->pid == 0)
8064 elf_tdata (abfd)->core->pid = prstat.pr_pid;
252b5132 8065
4a938328
MS
8066 /* pr_who exists on:
8067 solaris 2.5+
8068 unixware 4.2
8069 pr_who doesn't exist on:
8070 linux 2.[01]
8071 */
252b5132 8072#if defined (HAVE_PRSTATUS_T_PR_WHO)
228e534f 8073 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
261b8d08 8074#else
228e534f 8075 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
252b5132 8076#endif
4a938328 8077 }
7ee38065 8078#if defined (HAVE_PRSTATUS32_T)
4a938328
MS
8079 else if (note->descsz == sizeof (prstatus32_t))
8080 {
8081 /* 64-bit host, 32-bit corefile */
8082 prstatus32_t prstat;
8083
eea6121a 8084 size = sizeof (prstat.pr_reg);
7ee38065 8085 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS
8086 memcpy (&prstat, note->descdata, sizeof (prstat));
8087
fa49d224
NC
8088 /* Do not overwrite the core signal if it
8089 has already been set by another thread. */
228e534f
AM
8090 if (elf_tdata (abfd)->core->signal == 0)
8091 elf_tdata (abfd)->core->signal = prstat.pr_cursig;
8092 if (elf_tdata (abfd)->core->pid == 0)
8093 elf_tdata (abfd)->core->pid = prstat.pr_pid;
4a938328
MS
8094
8095 /* pr_who exists on:
8096 solaris 2.5+
8097 unixware 4.2
8098 pr_who doesn't exist on:
8099 linux 2.[01]
8100 */
7ee38065 8101#if defined (HAVE_PRSTATUS32_T_PR_WHO)
228e534f 8102 elf_tdata (abfd)->core->lwpid = prstat.pr_who;
261b8d08 8103#else
228e534f 8104 elf_tdata (abfd)->core->lwpid = prstat.pr_pid;
4a938328
MS
8105#endif
8106 }
7ee38065 8107#endif /* HAVE_PRSTATUS32_T */
4a938328
MS
8108 else
8109 {
8110 /* Fail - we don't know how to handle any other
8111 note size (ie. data object type). */
b34976b6 8112 return TRUE;
4a938328 8113 }
252b5132 8114
bb0082d6 8115 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 8116 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 8117 size, note->descpos + offset);
252b5132
RH
8118}
8119#endif /* defined (HAVE_PRSTATUS_T) */
8120
bb0082d6 8121/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 8122static bfd_boolean
217aa764
AM
8123elfcore_make_note_pseudosection (bfd *abfd,
8124 char *name,
8125 Elf_Internal_Note *note)
252b5132 8126{
936e320b
AM
8127 return _bfd_elfcore_make_pseudosection (abfd, name,
8128 note->descsz, note->descpos);
252b5132
RH
8129}
8130
ff08c6bb
JB
8131/* There isn't a consistent prfpregset_t across platforms,
8132 but it doesn't matter, because we don't have to pick this
c044fabd
KH
8133 data structure apart. */
8134
b34976b6 8135static bfd_boolean
217aa764 8136elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB
8137{
8138 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8139}
8140
ff08c6bb 8141/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
971d4640 8142 type of NT_PRXFPREG. Just include the whole note's contents
ff08c6bb 8143 literally. */
c044fabd 8144
b34976b6 8145static bfd_boolean
217aa764 8146elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB
8147{
8148 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8149}
8150
4339cae0
L
8151/* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
8152 with a note type of NT_X86_XSTATE. Just include the whole note's
8153 contents literally. */
8154
8155static bfd_boolean
8156elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
8157{
8158 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
8159}
8160
97753bd5
AM
8161static bfd_boolean
8162elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
8163{
8164 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
8165}
8166
89eeb0bc
LM
8167static bfd_boolean
8168elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
8169{
8170 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
8171}
97753bd5 8172
0675e188
UW
8173static bfd_boolean
8174elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
8175{
8176 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
8177}
8178
d7eeb400
MS
8179static bfd_boolean
8180elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
8181{
8182 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
8183}
8184
8185static bfd_boolean
8186elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
8187{
8188 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
8189}
8190
8191static bfd_boolean
8192elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
8193{
8194 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
8195}
8196
8197static bfd_boolean
8198elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
8199{
8200 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
8201}
8202
8203static bfd_boolean
8204elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
8205{
8206 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
8207}
8208
355b81d9
UW
8209static bfd_boolean
8210elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
8211{
8212 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
8213}
8214
8215static bfd_boolean
8216elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
8217{
8218 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
8219}
8220
abb3f6cc
NC
8221static bfd_boolean
8222elfcore_grok_s390_tdb (bfd *abfd, Elf_Internal_Note *note)
8223{
8224 return elfcore_make_note_pseudosection (abfd, ".reg-s390-tdb", note);
8225}
8226
faa9a424
UW
8227static bfd_boolean
8228elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
8229{
8230 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
8231}
8232
652451f8
YZ
8233static bfd_boolean
8234elfcore_grok_aarch_tls (bfd *abfd, Elf_Internal_Note *note)
8235{
8236 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-tls", note);
8237}
8238
8239static bfd_boolean
8240elfcore_grok_aarch_hw_break (bfd *abfd, Elf_Internal_Note *note)
8241{
8242 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-break", note);
8243}
8244
8245static bfd_boolean
8246elfcore_grok_aarch_hw_watch (bfd *abfd, Elf_Internal_Note *note)
8247{
8248 return elfcore_make_note_pseudosection (abfd, ".reg-aarch-hw-watch", note);
8249}
8250
252b5132 8251#if defined (HAVE_PRPSINFO_T)
4a938328 8252typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 8253#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS
8254typedef prpsinfo32_t elfcore_psinfo32_t;
8255#endif
252b5132
RH
8256#endif
8257
8258#if defined (HAVE_PSINFO_T)
4a938328 8259typedef psinfo_t elfcore_psinfo_t;
7ee38065 8260#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS
8261typedef psinfo32_t elfcore_psinfo32_t;
8262#endif
252b5132
RH
8263#endif
8264
252b5132
RH
8265/* return a malloc'ed copy of a string at START which is at
8266 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 8267 the copy will always have a terminating '\0'. */
252b5132 8268
936e320b 8269char *
217aa764 8270_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 8271{
dc810e39 8272 char *dups;
a50b1753 8273 char *end = (char *) memchr (start, '\0', max);
dc810e39 8274 size_t len;
252b5132
RH
8275
8276 if (end == NULL)
8277 len = max;
8278 else
8279 len = end - start;
8280
a50b1753 8281 dups = (char *) bfd_alloc (abfd, len + 1);
dc810e39 8282 if (dups == NULL)
252b5132
RH
8283 return NULL;
8284
dc810e39
AM
8285 memcpy (dups, start, len);
8286 dups[len] = '\0';
252b5132 8287
dc810e39 8288 return dups;
252b5132
RH
8289}
8290
bb0082d6 8291#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 8292static bfd_boolean
217aa764 8293elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 8294{
4a938328
MS
8295 if (note->descsz == sizeof (elfcore_psinfo_t))
8296 {
8297 elfcore_psinfo_t psinfo;
252b5132 8298
7ee38065 8299 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 8300
335e41d4 8301#if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
228e534f 8302 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
335e41d4 8303#endif
228e534f 8304 elf_tdata (abfd)->core->program
936e320b
AM
8305 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8306 sizeof (psinfo.pr_fname));
252b5132 8307
228e534f 8308 elf_tdata (abfd)->core->command
936e320b
AM
8309 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8310 sizeof (psinfo.pr_psargs));
4a938328 8311 }
7ee38065 8312#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS
8313 else if (note->descsz == sizeof (elfcore_psinfo32_t))
8314 {
8315 /* 64-bit host, 32-bit corefile */
8316 elfcore_psinfo32_t psinfo;
8317
7ee38065 8318 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 8319
335e41d4 8320#if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
228e534f 8321 elf_tdata (abfd)->core->pid = psinfo.pr_pid;
335e41d4 8322#endif
228e534f 8323 elf_tdata (abfd)->core->program
936e320b
AM
8324 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8325 sizeof (psinfo.pr_fname));
4a938328 8326
228e534f 8327 elf_tdata (abfd)->core->command
936e320b
AM
8328 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8329 sizeof (psinfo.pr_psargs));
4a938328
MS
8330 }
8331#endif
8332
8333 else
8334 {
8335 /* Fail - we don't know how to handle any other
8336 note size (ie. data object type). */
b34976b6 8337 return TRUE;
4a938328 8338 }
252b5132
RH
8339
8340 /* Note that for some reason, a spurious space is tacked
8341 onto the end of the args in some (at least one anyway)
c044fabd 8342 implementations, so strip it off if it exists. */
252b5132
RH
8343
8344 {
228e534f 8345 char *command = elf_tdata (abfd)->core->command;
252b5132
RH
8346 int n = strlen (command);
8347
8348 if (0 < n && command[n - 1] == ' ')
8349 command[n - 1] = '\0';
8350 }
8351
b34976b6 8352 return TRUE;
252b5132
RH
8353}
8354#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8355
252b5132 8356#if defined (HAVE_PSTATUS_T)
b34976b6 8357static bfd_boolean
217aa764 8358elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 8359{
f572a39d
AM
8360 if (note->descsz == sizeof (pstatus_t)
8361#if defined (HAVE_PXSTATUS_T)
8362 || note->descsz == sizeof (pxstatus_t)
8363#endif
8364 )
4a938328
MS
8365 {
8366 pstatus_t pstat;
252b5132 8367
4a938328 8368 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 8369
228e534f 8370 elf_tdata (abfd)->core->pid = pstat.pr_pid;
4a938328 8371 }
7ee38065 8372#if defined (HAVE_PSTATUS32_T)
4a938328
MS
8373 else if (note->descsz == sizeof (pstatus32_t))
8374 {
8375 /* 64-bit host, 32-bit corefile */
8376 pstatus32_t pstat;
252b5132 8377
4a938328 8378 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 8379
228e534f 8380 elf_tdata (abfd)->core->pid = pstat.pr_pid;
4a938328
MS
8381 }
8382#endif
252b5132
RH
8383 /* Could grab some more details from the "representative"
8384 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 8385 NT_LWPSTATUS note, presumably. */
252b5132 8386
b34976b6 8387 return TRUE;
252b5132
RH
8388}
8389#endif /* defined (HAVE_PSTATUS_T) */
8390
252b5132 8391#if defined (HAVE_LWPSTATUS_T)
b34976b6 8392static bfd_boolean
217aa764 8393elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH
8394{
8395 lwpstatus_t lwpstat;
8396 char buf[100];
c044fabd 8397 char *name;
d4c88bbb 8398 size_t len;
c044fabd 8399 asection *sect;
252b5132 8400
f572a39d
AM
8401 if (note->descsz != sizeof (lwpstat)
8402#if defined (HAVE_LWPXSTATUS_T)
8403 && note->descsz != sizeof (lwpxstatus_t)
8404#endif
8405 )
b34976b6 8406 return TRUE;
252b5132
RH
8407
8408 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
8409
228e534f 8410 elf_tdata (abfd)->core->lwpid = lwpstat.pr_lwpid;
a1504221
JB
8411 /* Do not overwrite the core signal if it has already been set by
8412 another thread. */
228e534f
AM
8413 if (elf_tdata (abfd)->core->signal == 0)
8414 elf_tdata (abfd)->core->signal = lwpstat.pr_cursig;
252b5132 8415
c044fabd 8416 /* Make a ".reg/999" section. */
252b5132
RH
8417
8418 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 8419 len = strlen (buf) + 1;
217aa764 8420 name = bfd_alloc (abfd, len);
252b5132 8421 if (name == NULL)
b34976b6 8422 return FALSE;
d4c88bbb 8423 memcpy (name, buf, len);
252b5132 8424
117ed4f8 8425 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 8426 if (sect == NULL)
b34976b6 8427 return FALSE;
252b5132
RH
8428
8429#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 8430 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH
8431 sect->filepos = note->descpos
8432 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
8433#endif
8434
8435#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 8436 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH
8437 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
8438#endif
8439
252b5132
RH
8440 sect->alignment_power = 2;
8441
8442 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 8443 return FALSE;
252b5132
RH
8444
8445 /* Make a ".reg2/999" section */
8446
8447 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 8448 len = strlen (buf) + 1;
217aa764 8449 name = bfd_alloc (abfd, len);
252b5132 8450 if (name == NULL)
b34976b6 8451 return FALSE;
d4c88bbb 8452 memcpy (name, buf, len);
252b5132 8453
117ed4f8 8454 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 8455 if (sect == NULL)
b34976b6 8456 return FALSE;
252b5132
RH
8457
8458#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 8459 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH
8460 sect->filepos = note->descpos
8461 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
8462#endif
8463
8464#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 8465 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH
8466 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
8467#endif
8468
252b5132
RH
8469 sect->alignment_power = 2;
8470
936e320b 8471 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH
8472}
8473#endif /* defined (HAVE_LWPSTATUS_T) */
8474
b34976b6 8475static bfd_boolean
217aa764 8476elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC
8477{
8478 char buf[30];
c044fabd 8479 char *name;
d4c88bbb 8480 size_t len;
c044fabd 8481 asection *sect;
4a6636fb
PA
8482 int type;
8483 int is_active_thread;
8484 bfd_vma base_addr;
16e9c715 8485
4a6636fb 8486 if (note->descsz < 728)
b34976b6 8487 return TRUE;
16e9c715 8488
4a6636fb
PA
8489 if (! CONST_STRNEQ (note->namedata, "win32"))
8490 return TRUE;
8491
8492 type = bfd_get_32 (abfd, note->descdata);
c044fabd 8493
4a6636fb 8494 switch (type)
16e9c715 8495 {
4a6636fb 8496 case 1 /* NOTE_INFO_PROCESS */:
228e534f 8497 /* FIXME: need to add ->core->command. */
4a6636fb 8498 /* process_info.pid */
228e534f 8499 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 8);
4a6636fb 8500 /* process_info.signal */
228e534f 8501 elf_tdata (abfd)->core->signal = bfd_get_32 (abfd, note->descdata + 12);
c044fabd 8502 break;
16e9c715 8503
4a6636fb 8504 case 2 /* NOTE_INFO_THREAD */:
16e9c715 8505 /* Make a ".reg/999" section. */
4a6636fb
PA
8506 /* thread_info.tid */
8507 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
c044fabd 8508
d4c88bbb 8509 len = strlen (buf) + 1;
a50b1753 8510 name = (char *) bfd_alloc (abfd, len);
16e9c715 8511 if (name == NULL)
b34976b6 8512 return FALSE;
c044fabd 8513
d4c88bbb 8514 memcpy (name, buf, len);
16e9c715 8515
117ed4f8 8516 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
16e9c715 8517 if (sect == NULL)
b34976b6 8518 return FALSE;
c044fabd 8519
4a6636fb
PA
8520 /* sizeof (thread_info.thread_context) */
8521 sect->size = 716;
8522 /* offsetof (thread_info.thread_context) */
8523 sect->filepos = note->descpos + 12;
16e9c715
NC
8524 sect->alignment_power = 2;
8525
4a6636fb
PA
8526 /* thread_info.is_active_thread */
8527 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8528
8529 if (is_active_thread)
16e9c715 8530 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 8531 return FALSE;
16e9c715
NC
8532 break;
8533
4a6636fb 8534 case 3 /* NOTE_INFO_MODULE */:
16e9c715 8535 /* Make a ".module/xxxxxxxx" section. */
4a6636fb
PA
8536 /* module_info.base_address */
8537 base_addr = bfd_get_32 (abfd, note->descdata + 4);
0af1713e 8538 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
c044fabd 8539
d4c88bbb 8540 len = strlen (buf) + 1;
a50b1753 8541 name = (char *) bfd_alloc (abfd, len);
16e9c715 8542 if (name == NULL)
b34976b6 8543 return FALSE;
c044fabd 8544
d4c88bbb 8545 memcpy (name, buf, len);
252b5132 8546
117ed4f8 8547 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
c044fabd 8548
16e9c715 8549 if (sect == NULL)
b34976b6 8550 return FALSE;
c044fabd 8551
eea6121a 8552 sect->size = note->descsz;
16e9c715 8553 sect->filepos = note->descpos;
16e9c715
NC
8554 sect->alignment_power = 2;
8555 break;
8556
8557 default:
b34976b6 8558 return TRUE;
16e9c715
NC
8559 }
8560
b34976b6 8561 return TRUE;
16e9c715 8562}
252b5132 8563
b34976b6 8564static bfd_boolean
217aa764 8565elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 8566{
9c5bfbb7 8567 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 8568
252b5132
RH
8569 switch (note->type)
8570 {
8571 default:
b34976b6 8572 return TRUE;
252b5132 8573
252b5132 8574 case NT_PRSTATUS:
bb0082d6
AM
8575 if (bed->elf_backend_grok_prstatus)
8576 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 8577 return TRUE;
bb0082d6 8578#if defined (HAVE_PRSTATUS_T)
252b5132 8579 return elfcore_grok_prstatus (abfd, note);
bb0082d6 8580#else
b34976b6 8581 return TRUE;
252b5132
RH
8582#endif
8583
8584#if defined (HAVE_PSTATUS_T)
8585 case NT_PSTATUS:
8586 return elfcore_grok_pstatus (abfd, note);
8587#endif
8588
8589#if defined (HAVE_LWPSTATUS_T)
8590 case NT_LWPSTATUS:
8591 return elfcore_grok_lwpstatus (abfd, note);
8592#endif
8593
8594 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
8595 return elfcore_grok_prfpreg (abfd, note);
8596
c044fabd 8597 case NT_WIN32PSTATUS:
16e9c715 8598 return elfcore_grok_win32pstatus (abfd, note);
16e9c715 8599
c044fabd 8600 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK
8601 if (note->namesz == 6
8602 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB
8603 return elfcore_grok_prxfpreg (abfd, note);
8604 else
b34976b6 8605 return TRUE;
ff08c6bb 8606
4339cae0
L
8607 case NT_X86_XSTATE: /* Linux XSAVE extension */
8608 if (note->namesz == 6
8609 && strcmp (note->namedata, "LINUX") == 0)
8610 return elfcore_grok_xstatereg (abfd, note);
8611 else
8612 return TRUE;
8613
97753bd5
AM
8614 case NT_PPC_VMX:
8615 if (note->namesz == 6
8616 && strcmp (note->namedata, "LINUX") == 0)
8617 return elfcore_grok_ppc_vmx (abfd, note);
8618 else
8619 return TRUE;
8620
89eeb0bc
LM
8621 case NT_PPC_VSX:
8622 if (note->namesz == 6
8623 && strcmp (note->namedata, "LINUX") == 0)
8624 return elfcore_grok_ppc_vsx (abfd, note);
8625 else
8626 return TRUE;
8627
0675e188
UW
8628 case NT_S390_HIGH_GPRS:
8629 if (note->namesz == 6
8630 && strcmp (note->namedata, "LINUX") == 0)
8631 return elfcore_grok_s390_high_gprs (abfd, note);
8632 else
8633 return TRUE;
8634
d7eeb400
MS
8635 case NT_S390_TIMER:
8636 if (note->namesz == 6
8637 && strcmp (note->namedata, "LINUX") == 0)
8638 return elfcore_grok_s390_timer (abfd, note);
8639 else
8640 return TRUE;
8641
8642 case NT_S390_TODCMP:
8643 if (note->namesz == 6
8644 && strcmp (note->namedata, "LINUX") == 0)
8645 return elfcore_grok_s390_todcmp (abfd, note);
8646 else
8647 return TRUE;
8648
8649 case NT_S390_TODPREG:
8650 if (note->namesz == 6
8651 && strcmp (note->namedata, "LINUX") == 0)
8652 return elfcore_grok_s390_todpreg (abfd, note);
8653 else
8654 return TRUE;
8655
8656 case NT_S390_CTRS:
8657 if (note->namesz == 6
8658 && strcmp (note->namedata, "LINUX") == 0)
8659 return elfcore_grok_s390_ctrs (abfd, note);
8660 else
8661 return TRUE;
8662
8663 case NT_S390_PREFIX:
8664 if (note->namesz == 6
8665 && strcmp (note->namedata, "LINUX") == 0)
8666 return elfcore_grok_s390_prefix (abfd, note);
8667 else
8668 return TRUE;
8669
355b81d9
UW
8670 case NT_S390_LAST_BREAK:
8671 if (note->namesz == 6
8672 && strcmp (note->namedata, "LINUX") == 0)
8673 return elfcore_grok_s390_last_break (abfd, note);
8674 else
8675 return TRUE;
8676
8677 case NT_S390_SYSTEM_CALL:
8678 if (note->namesz == 6
8679 && strcmp (note->namedata, "LINUX") == 0)
8680 return elfcore_grok_s390_system_call (abfd, note);
8681 else
8682 return TRUE;
8683
abb3f6cc
NC
8684 case NT_S390_TDB:
8685 if (note->namesz == 6
8686 && strcmp (note->namedata, "LINUX") == 0)
8687 return elfcore_grok_s390_tdb (abfd, note);
8688 else
8689 return TRUE;
8690
faa9a424
UW
8691 case NT_ARM_VFP:
8692 if (note->namesz == 6
8693 && strcmp (note->namedata, "LINUX") == 0)
8694 return elfcore_grok_arm_vfp (abfd, note);
8695 else
8696 return TRUE;
8697
652451f8
YZ
8698 case NT_ARM_TLS:
8699 if (note->namesz == 6
8700 && strcmp (note->namedata, "LINUX") == 0)
8701 return elfcore_grok_aarch_tls (abfd, note);
8702 else
8703 return TRUE;
8704
8705 case NT_ARM_HW_BREAK:
8706 if (note->namesz == 6
8707 && strcmp (note->namedata, "LINUX") == 0)
8708 return elfcore_grok_aarch_hw_break (abfd, note);
8709 else
8710 return TRUE;
8711
8712 case NT_ARM_HW_WATCH:
8713 if (note->namesz == 6
8714 && strcmp (note->namedata, "LINUX") == 0)
8715 return elfcore_grok_aarch_hw_watch (abfd, note);
8716 else
8717 return TRUE;
8718
252b5132
RH
8719 case NT_PRPSINFO:
8720 case NT_PSINFO:
bb0082d6
AM
8721 if (bed->elf_backend_grok_psinfo)
8722 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 8723 return TRUE;
bb0082d6 8724#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 8725 return elfcore_grok_psinfo (abfd, note);
bb0082d6 8726#else
b34976b6 8727 return TRUE;
252b5132 8728#endif
3333a7c3
RM
8729
8730 case NT_AUXV:
8731 {
117ed4f8
AM
8732 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8733 SEC_HAS_CONTENTS);
3333a7c3
RM
8734
8735 if (sect == NULL)
8736 return FALSE;
eea6121a 8737 sect->size = note->descsz;
3333a7c3 8738 sect->filepos = note->descpos;
3333a7c3
RM
8739 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8740
8741 return TRUE;
8742 }
9015683b 8743
451b7c33
TT
8744 case NT_FILE:
8745 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.file",
8746 note);
8747
9015683b
TT
8748 case NT_SIGINFO:
8749 return elfcore_make_note_pseudosection (abfd, ".note.linuxcore.siginfo",
8750 note);
252b5132
RH
8751 }
8752}
8753
718175fa
JK
8754static bfd_boolean
8755elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8756{
30e8ee25
AM
8757 struct elf_obj_tdata *t;
8758
8759 if (note->descsz == 0)
8760 return FALSE;
8761
8762 t = elf_tdata (abfd);
c0355132 8763 t->build_id = bfd_alloc (abfd, sizeof (*t->build_id) - 1 + note->descsz);
30e8ee25 8764 if (t->build_id == NULL)
718175fa
JK
8765 return FALSE;
8766
c0355132
AM
8767 t->build_id->size = note->descsz;
8768 memcpy (t->build_id->data, note->descdata, note->descsz);
718175fa
JK
8769
8770 return TRUE;
8771}
8772
8773static bfd_boolean
8774elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8775{
8776 switch (note->type)
8777 {
8778 default:
8779 return TRUE;
8780
8781 case NT_GNU_BUILD_ID:
8782 return elfobj_grok_gnu_build_id (abfd, note);
8783 }
8784}
8785
e21e5835
NC
8786static bfd_boolean
8787elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
8788{
8789 struct sdt_note *cur =
8790 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
8791 + note->descsz);
8792
8793 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
8794 cur->size = (bfd_size_type) note->descsz;
8795 memcpy (cur->data, note->descdata, note->descsz);
8796
8797 elf_tdata (abfd)->sdt_note_head = cur;
8798
8799 return TRUE;
8800}
8801
8802static bfd_boolean
8803elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
8804{
8805 switch (note->type)
8806 {
8807 case NT_STAPSDT:
8808 return elfobj_grok_stapsdt_note_1 (abfd, note);
8809
8810 default:
8811 return TRUE;
8812 }
8813}
8814
b34976b6 8815static bfd_boolean
217aa764 8816elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM
8817{
8818 char *cp;
8819
8820 cp = strchr (note->namedata, '@');
8821 if (cp != NULL)
8822 {
d2b64500 8823 *lwpidp = atoi(cp + 1);
b34976b6 8824 return TRUE;
50b2bdb7 8825 }
b34976b6 8826 return FALSE;
50b2bdb7
AM
8827}
8828
b34976b6 8829static bfd_boolean
217aa764 8830elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7 8831{
50b2bdb7 8832 /* Signal number at offset 0x08. */
228e534f 8833 elf_tdata (abfd)->core->signal
50b2bdb7
AM
8834 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8835
8836 /* Process ID at offset 0x50. */
228e534f 8837 elf_tdata (abfd)->core->pid
50b2bdb7
AM
8838 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8839
8840 /* Command name at 0x7c (max 32 bytes, including nul). */
228e534f 8841 elf_tdata (abfd)->core->command
50b2bdb7
AM
8842 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8843
7720ba9f
MK
8844 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8845 note);
50b2bdb7
AM
8846}
8847
b34976b6 8848static bfd_boolean
217aa764 8849elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM
8850{
8851 int lwp;
8852
8853 if (elfcore_netbsd_get_lwpid (note, &lwp))
228e534f 8854 elf_tdata (abfd)->core->lwpid = lwp;
50b2bdb7 8855
b4db1224 8856 if (note->type == NT_NETBSDCORE_PROCINFO)
50b2bdb7
AM
8857 {
8858 /* NetBSD-specific core "procinfo". Note that we expect to
08a40648
AM
8859 find this note before any of the others, which is fine,
8860 since the kernel writes this note out first when it
8861 creates a core file. */
47d9a591 8862
50b2bdb7
AM
8863 return elfcore_grok_netbsd_procinfo (abfd, note);
8864 }
8865
b4db1224
JT
8866 /* As of Jan 2002 there are no other machine-independent notes
8867 defined for NetBSD core files. If the note type is less
8868 than the start of the machine-dependent note types, we don't
8869 understand it. */
47d9a591 8870
b4db1224 8871 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 8872 return TRUE;
50b2bdb7
AM
8873
8874
8875 switch (bfd_get_arch (abfd))
8876 {
08a40648
AM
8877 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8878 PT_GETFPREGS == mach+2. */
50b2bdb7
AM
8879
8880 case bfd_arch_alpha:
8881 case bfd_arch_sparc:
8882 switch (note->type)
08a40648
AM
8883 {
8884 case NT_NETBSDCORE_FIRSTMACH+0:
8885 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 8886
08a40648
AM
8887 case NT_NETBSDCORE_FIRSTMACH+2:
8888 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 8889
08a40648
AM
8890 default:
8891 return TRUE;
8892 }
50b2bdb7 8893
08a40648
AM
8894 /* On all other arch's, PT_GETREGS == mach+1 and
8895 PT_GETFPREGS == mach+3. */
50b2bdb7
AM
8896
8897 default:
8898 switch (note->type)
08a40648
AM
8899 {
8900 case NT_NETBSDCORE_FIRSTMACH+1:
8901 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 8902
08a40648
AM
8903 case NT_NETBSDCORE_FIRSTMACH+3:
8904 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 8905
08a40648
AM
8906 default:
8907 return TRUE;
8908 }
50b2bdb7
AM
8909 }
8910 /* NOTREACHED */
8911}
8912
67cc5033
MK
8913static bfd_boolean
8914elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8915{
8916 /* Signal number at offset 0x08. */
228e534f 8917 elf_tdata (abfd)->core->signal
67cc5033
MK
8918 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8919
8920 /* Process ID at offset 0x20. */
228e534f 8921 elf_tdata (abfd)->core->pid
67cc5033
MK
8922 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8923
8924 /* Command name at 0x48 (max 32 bytes, including nul). */
228e534f 8925 elf_tdata (abfd)->core->command
67cc5033
MK
8926 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8927
8928 return TRUE;
8929}
8930
8931static bfd_boolean
8932elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8933{
8934 if (note->type == NT_OPENBSD_PROCINFO)
8935 return elfcore_grok_openbsd_procinfo (abfd, note);
8936
8937 if (note->type == NT_OPENBSD_REGS)
8938 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8939
8940 if (note->type == NT_OPENBSD_FPREGS)
8941 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8942
8943 if (note->type == NT_OPENBSD_XFPREGS)
8944 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8945
8946 if (note->type == NT_OPENBSD_AUXV)
8947 {
8948 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8949 SEC_HAS_CONTENTS);
8950
8951 if (sect == NULL)
8952 return FALSE;
8953 sect->size = note->descsz;
8954 sect->filepos = note->descpos;
8955 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8956
8957 return TRUE;
8958 }
8959
8960 if (note->type == NT_OPENBSD_WCOOKIE)
8961 {
8962 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8963 SEC_HAS_CONTENTS);
8964
8965 if (sect == NULL)
8966 return FALSE;
8967 sect->size = note->descsz;
8968 sect->filepos = note->descpos;
8969 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8970
8971 return TRUE;
8972 }
8973
8974 return TRUE;
8975}
8976
07c6e936 8977static bfd_boolean
d3fd4074 8978elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
07c6e936
NC
8979{
8980 void *ddata = note->descdata;
8981 char buf[100];
8982 char *name;
8983 asection *sect;
f8843e87
AM
8984 short sig;
8985 unsigned flags;
07c6e936
NC
8986
8987 /* nto_procfs_status 'pid' field is at offset 0. */
228e534f 8988 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
07c6e936 8989
f8843e87
AM
8990 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8991 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8992
8993 /* nto_procfs_status 'flags' field is at offset 8. */
8994 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC
8995
8996 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM
8997 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8998 {
228e534f
AM
8999 elf_tdata (abfd)->core->signal = sig;
9000 elf_tdata (abfd)->core->lwpid = *tid;
f8843e87 9001 }
07c6e936 9002
f8843e87
AM
9003 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
9004 do not come from signals so we make sure we set the current
9005 thread just in case. */
9006 if (flags & 0x00000080)
228e534f 9007 elf_tdata (abfd)->core->lwpid = *tid;
07c6e936
NC
9008
9009 /* Make a ".qnx_core_status/%d" section. */
d3fd4074 9010 sprintf (buf, ".qnx_core_status/%ld", *tid);
07c6e936 9011
a50b1753 9012 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC
9013 if (name == NULL)
9014 return FALSE;
9015 strcpy (name, buf);
9016
117ed4f8 9017 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC
9018 if (sect == NULL)
9019 return FALSE;
9020
eea6121a 9021 sect->size = note->descsz;
07c6e936 9022 sect->filepos = note->descpos;
07c6e936
NC
9023 sect->alignment_power = 2;
9024
9025 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
9026}
9027
9028static bfd_boolean
d69f560c
KW
9029elfcore_grok_nto_regs (bfd *abfd,
9030 Elf_Internal_Note *note,
d3fd4074 9031 long tid,
d69f560c 9032 char *base)
07c6e936
NC
9033{
9034 char buf[100];
9035 char *name;
9036 asection *sect;
9037
d69f560c 9038 /* Make a "(base)/%d" section. */
d3fd4074 9039 sprintf (buf, "%s/%ld", base, tid);
07c6e936 9040
a50b1753 9041 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC
9042 if (name == NULL)
9043 return FALSE;
9044 strcpy (name, buf);
9045
117ed4f8 9046 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC
9047 if (sect == NULL)
9048 return FALSE;
9049
eea6121a 9050 sect->size = note->descsz;
07c6e936 9051 sect->filepos = note->descpos;
07c6e936
NC
9052 sect->alignment_power = 2;
9053
f8843e87 9054 /* This is the current thread. */
228e534f 9055 if (elf_tdata (abfd)->core->lwpid == tid)
d69f560c 9056 return elfcore_maybe_make_sect (abfd, base, sect);
f8843e87
AM
9057
9058 return TRUE;
07c6e936
NC
9059}
9060
9061#define BFD_QNT_CORE_INFO 7
9062#define BFD_QNT_CORE_STATUS 8
9063#define BFD_QNT_CORE_GREG 9
9064#define BFD_QNT_CORE_FPREG 10
9065
9066static bfd_boolean
217aa764 9067elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC
9068{
9069 /* Every GREG section has a STATUS section before it. Store the
811072d8 9070 tid from the previous call to pass down to the next gregs
07c6e936 9071 function. */
d3fd4074 9072 static long tid = 1;
07c6e936
NC
9073
9074 switch (note->type)
9075 {
d69f560c
KW
9076 case BFD_QNT_CORE_INFO:
9077 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
9078 case BFD_QNT_CORE_STATUS:
9079 return elfcore_grok_nto_status (abfd, note, &tid);
9080 case BFD_QNT_CORE_GREG:
9081 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
9082 case BFD_QNT_CORE_FPREG:
9083 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
9084 default:
9085 return TRUE;
07c6e936
NC
9086 }
9087}
9088
b15fa79e
AM
9089static bfd_boolean
9090elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
9091{
9092 char *name;
9093 asection *sect;
9094 size_t len;
9095
9096 /* Use note name as section name. */
9097 len = note->namesz;
a50b1753 9098 name = (char *) bfd_alloc (abfd, len);
b15fa79e
AM
9099 if (name == NULL)
9100 return FALSE;
9101 memcpy (name, note->namedata, len);
9102 name[len - 1] = '\0';
9103
9104 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
9105 if (sect == NULL)
9106 return FALSE;
9107
9108 sect->size = note->descsz;
9109 sect->filepos = note->descpos;
9110 sect->alignment_power = 1;
9111
9112 return TRUE;
9113}
9114
7c76fa91
MS
9115/* Function: elfcore_write_note
9116
47d9a591 9117 Inputs:
a39f3346 9118 buffer to hold note, and current size of buffer
7c76fa91
MS
9119 name of note
9120 type of note
9121 data for note
9122 size of data for note
9123
a39f3346
AM
9124 Writes note to end of buffer. ELF64 notes are written exactly as
9125 for ELF32, despite the current (as of 2006) ELF gabi specifying
9126 that they ought to have 8-byte namesz and descsz field, and have
9127 8-byte alignment. Other writers, eg. Linux kernel, do the same.
9128
7c76fa91 9129 Return:
a39f3346 9130 Pointer to realloc'd buffer, *BUFSIZ updated. */
7c76fa91
MS
9131
9132char *
a39f3346 9133elfcore_write_note (bfd *abfd,
217aa764 9134 char *buf,
a39f3346 9135 int *bufsiz,
217aa764 9136 const char *name,
a39f3346 9137 int type,
217aa764 9138 const void *input,
a39f3346 9139 int size)
7c76fa91
MS
9140{
9141 Elf_External_Note *xnp;
d4c88bbb 9142 size_t namesz;
d4c88bbb 9143 size_t newspace;
a39f3346 9144 char *dest;
7c76fa91 9145
d4c88bbb 9146 namesz = 0;
d4c88bbb 9147 if (name != NULL)
a39f3346 9148 namesz = strlen (name) + 1;
d4c88bbb 9149
a39f3346 9150 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
d4c88bbb 9151
a50b1753 9152 buf = (char *) realloc (buf, *bufsiz + newspace);
14b1c01e
AM
9153 if (buf == NULL)
9154 return buf;
a39f3346 9155 dest = buf + *bufsiz;
7c76fa91
MS
9156 *bufsiz += newspace;
9157 xnp = (Elf_External_Note *) dest;
9158 H_PUT_32 (abfd, namesz, xnp->namesz);
9159 H_PUT_32 (abfd, size, xnp->descsz);
9160 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM
9161 dest = xnp->name;
9162 if (name != NULL)
9163 {
9164 memcpy (dest, name, namesz);
9165 dest += namesz;
a39f3346 9166 while (namesz & 3)
d4c88bbb
AM
9167 {
9168 *dest++ = '\0';
a39f3346 9169 ++namesz;
d4c88bbb
AM
9170 }
9171 }
9172 memcpy (dest, input, size);
a39f3346
AM
9173 dest += size;
9174 while (size & 3)
9175 {
9176 *dest++ = '\0';
9177 ++size;
9178 }
9179 return buf;
7c76fa91
MS
9180}
9181
7c76fa91 9182char *
217aa764
AM
9183elfcore_write_prpsinfo (bfd *abfd,
9184 char *buf,
9185 int *bufsiz,
9186 const char *fname,
9187 const char *psargs)
7c76fa91 9188{
183e98be
AM
9189 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9190
9191 if (bed->elf_backend_write_core_note != NULL)
9192 {
9193 char *ret;
9194 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
9195 NT_PRPSINFO, fname, psargs);
9196 if (ret != NULL)
9197 return ret;
9198 }
7c76fa91 9199
1f20dca5 9200#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
183e98be
AM
9201#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
9202 if (bed->s->elfclass == ELFCLASS32)
9203 {
9204#if defined (HAVE_PSINFO32_T)
9205 psinfo32_t data;
9206 int note_type = NT_PSINFO;
9207#else
9208 prpsinfo32_t data;
9209 int note_type = NT_PRPSINFO;
9210#endif
9211
9212 memset (&data, 0, sizeof (data));
9213 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
9214 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
9215 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 9216 "CORE", note_type, &data, sizeof (data));
183e98be
AM
9217 }
9218 else
9219#endif
9220 {
7c76fa91 9221#if defined (HAVE_PSINFO_T)
183e98be
AM
9222 psinfo_t data;
9223 int note_type = NT_PSINFO;
7c76fa91 9224#else
183e98be
AM
9225 prpsinfo_t data;
9226 int note_type = NT_PRPSINFO;
7c76fa91
MS
9227#endif
9228
183e98be
AM
9229 memset (&data, 0, sizeof (data));
9230 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
9231 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
9232 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 9233 "CORE", note_type, &data, sizeof (data));
183e98be 9234 }
7c76fa91
MS
9235#endif /* PSINFO_T or PRPSINFO_T */
9236
1f20dca5
UW
9237 free (buf);
9238 return NULL;
9239}
9240
70a38d42
SDJ
9241char *
9242elfcore_write_linux_prpsinfo32
9243 (bfd *abfd, char *buf, int *bufsiz,
9244 const struct elf_internal_linux_prpsinfo *prpsinfo)
9245{
9246 struct elf_external_linux_prpsinfo32 data;
9247
9248 memset (&data, 0, sizeof (data));
9249 LINUX_PRPSINFO32_SWAP_FIELDS (abfd, prpsinfo, data);
9250
9251 return elfcore_write_note (abfd, buf, bufsiz, "CORE", NT_PRPSINFO,
9252 &data, sizeof (data));
9253}
9254
9255char *
9256elfcore_write_linux_prpsinfo64
9257 (bfd *abfd, char *buf, int *bufsiz,
9258 const struct elf_internal_linux_prpsinfo *prpsinfo)
9259{
9260 struct elf_external_linux_prpsinfo64 data;
9261
9262 memset (&data, 0, sizeof (data));
9263 LINUX_PRPSINFO64_SWAP_FIELDS (abfd, prpsinfo, data);
9264
9265 return elfcore_write_note (abfd, buf, bufsiz,
9266 "CORE", NT_PRPSINFO, &data, sizeof (data));
9267}
9268
7c76fa91 9269char *
217aa764
AM
9270elfcore_write_prstatus (bfd *abfd,
9271 char *buf,
9272 int *bufsiz,
9273 long pid,
9274 int cursig,
9275 const void *gregs)
7c76fa91 9276{
183e98be 9277 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 9278
183e98be
AM
9279 if (bed->elf_backend_write_core_note != NULL)
9280 {
9281 char *ret;
9282 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
9283 NT_PRSTATUS,
9284 pid, cursig, gregs);
9285 if (ret != NULL)
9286 return ret;
9287 }
9288
1f20dca5 9289#if defined (HAVE_PRSTATUS_T)
183e98be
AM
9290#if defined (HAVE_PRSTATUS32_T)
9291 if (bed->s->elfclass == ELFCLASS32)
9292 {
9293 prstatus32_t prstat;
9294
9295 memset (&prstat, 0, sizeof (prstat));
9296 prstat.pr_pid = pid;
9297 prstat.pr_cursig = cursig;
9298 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 9299 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM
9300 NT_PRSTATUS, &prstat, sizeof (prstat));
9301 }
9302 else
9303#endif
9304 {
9305 prstatus_t prstat;
9306
9307 memset (&prstat, 0, sizeof (prstat));
9308 prstat.pr_pid = pid;
9309 prstat.pr_cursig = cursig;
9310 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 9311 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM
9312 NT_PRSTATUS, &prstat, sizeof (prstat));
9313 }
7c76fa91
MS
9314#endif /* HAVE_PRSTATUS_T */
9315
1f20dca5
UW
9316 free (buf);
9317 return NULL;
9318}
9319
51316059
MS
9320#if defined (HAVE_LWPSTATUS_T)
9321char *
217aa764
AM
9322elfcore_write_lwpstatus (bfd *abfd,
9323 char *buf,
9324 int *bufsiz,
9325 long pid,
9326 int cursig,
9327 const void *gregs)
51316059
MS
9328{
9329 lwpstatus_t lwpstat;
183e98be 9330 const char *note_name = "CORE";
51316059
MS
9331
9332 memset (&lwpstat, 0, sizeof (lwpstat));
9333 lwpstat.pr_lwpid = pid >> 16;
9334 lwpstat.pr_cursig = cursig;
9335#if defined (HAVE_LWPSTATUS_T_PR_REG)
9336 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
9337#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9338#if !defined(gregs)
9339 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
9340 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
9341#else
9342 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
9343 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
9344#endif
9345#endif
47d9a591 9346 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS
9347 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
9348}
9349#endif /* HAVE_LWPSTATUS_T */
9350
7c76fa91
MS
9351#if defined (HAVE_PSTATUS_T)
9352char *
217aa764
AM
9353elfcore_write_pstatus (bfd *abfd,
9354 char *buf,
9355 int *bufsiz,
9356 long pid,
6c10990d
NC
9357 int cursig ATTRIBUTE_UNUSED,
9358 const void *gregs ATTRIBUTE_UNUSED)
7c76fa91 9359{
183e98be
AM
9360 const char *note_name = "CORE";
9361#if defined (HAVE_PSTATUS32_T)
9362 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 9363
183e98be
AM
9364 if (bed->s->elfclass == ELFCLASS32)
9365 {
9366 pstatus32_t pstat;
9367
9368 memset (&pstat, 0, sizeof (pstat));
9369 pstat.pr_pid = pid & 0xffff;
9370 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9371 NT_PSTATUS, &pstat, sizeof (pstat));
9372 return buf;
9373 }
9374 else
9375#endif
9376 {
9377 pstatus_t pstat;
9378
9379 memset (&pstat, 0, sizeof (pstat));
9380 pstat.pr_pid = pid & 0xffff;
9381 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9382 NT_PSTATUS, &pstat, sizeof (pstat));
9383 return buf;
9384 }
7c76fa91
MS
9385}
9386#endif /* HAVE_PSTATUS_T */
9387
9388char *
217aa764
AM
9389elfcore_write_prfpreg (bfd *abfd,
9390 char *buf,
9391 int *bufsiz,
9392 const void *fpregs,
9393 int size)
7c76fa91 9394{
183e98be 9395 const char *note_name = "CORE";
47d9a591 9396 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS
9397 note_name, NT_FPREGSET, fpregs, size);
9398}
9399
9400char *
217aa764
AM
9401elfcore_write_prxfpreg (bfd *abfd,
9402 char *buf,
9403 int *bufsiz,
9404 const void *xfpregs,
9405 int size)
7c76fa91
MS
9406{
9407 char *note_name = "LINUX";
47d9a591 9408 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS
9409 note_name, NT_PRXFPREG, xfpregs, size);
9410}
9411
4339cae0
L
9412char *
9413elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
9414 const void *xfpregs, int size)
9415{
9416 char *note_name = "LINUX";
9417 return elfcore_write_note (abfd, buf, bufsiz,
9418 note_name, NT_X86_XSTATE, xfpregs, size);
9419}
9420
97753bd5
AM
9421char *
9422elfcore_write_ppc_vmx (bfd *abfd,
9423 char *buf,
9424 int *bufsiz,
9425 const void *ppc_vmx,
9426 int size)
9427{
9428 char *note_name = "LINUX";
9429 return elfcore_write_note (abfd, buf, bufsiz,
9430 note_name, NT_PPC_VMX, ppc_vmx, size);
9431}
9432
89eeb0bc
LM
9433char *
9434elfcore_write_ppc_vsx (bfd *abfd,
9435 char *buf,
9436 int *bufsiz,
9437 const void *ppc_vsx,
9438 int size)
9439{
9440 char *note_name = "LINUX";
9441 return elfcore_write_note (abfd, buf, bufsiz,
9442 note_name, NT_PPC_VSX, ppc_vsx, size);
9443}
9444
0675e188
UW
9445static char *
9446elfcore_write_s390_high_gprs (bfd *abfd,
9447 char *buf,
9448 int *bufsiz,
9449 const void *s390_high_gprs,
9450 int size)
9451{
9452 char *note_name = "LINUX";
9453 return elfcore_write_note (abfd, buf, bufsiz,
9454 note_name, NT_S390_HIGH_GPRS,
9455 s390_high_gprs, size);
9456}
9457
d7eeb400
MS
9458char *
9459elfcore_write_s390_timer (bfd *abfd,
9460 char *buf,
9461 int *bufsiz,
9462 const void *s390_timer,
9463 int size)
9464{
9465 char *note_name = "LINUX";
9466 return elfcore_write_note (abfd, buf, bufsiz,
9467 note_name, NT_S390_TIMER, s390_timer, size);
9468}
9469
9470char *
9471elfcore_write_s390_todcmp (bfd *abfd,
9472 char *buf,
9473 int *bufsiz,
9474 const void *s390_todcmp,
9475 int size)
9476{
9477 char *note_name = "LINUX";
9478 return elfcore_write_note (abfd, buf, bufsiz,
9479 note_name, NT_S390_TODCMP, s390_todcmp, size);
9480}
9481
9482char *
9483elfcore_write_s390_todpreg (bfd *abfd,
9484 char *buf,
9485 int *bufsiz,
9486 const void *s390_todpreg,
9487 int size)
9488{
9489 char *note_name = "LINUX";
9490 return elfcore_write_note (abfd, buf, bufsiz,
9491 note_name, NT_S390_TODPREG, s390_todpreg, size);
9492}
9493
9494char *
9495elfcore_write_s390_ctrs (bfd *abfd,
9496 char *buf,
9497 int *bufsiz,
9498 const void *s390_ctrs,
9499 int size)
9500{
9501 char *note_name = "LINUX";
9502 return elfcore_write_note (abfd, buf, bufsiz,
9503 note_name, NT_S390_CTRS, s390_ctrs, size);
9504}
9505
9506char *
9507elfcore_write_s390_prefix (bfd *abfd,
9508 char *buf,
9509 int *bufsiz,
9510 const void *s390_prefix,
9511 int size)
9512{
9513 char *note_name = "LINUX";
9514 return elfcore_write_note (abfd, buf, bufsiz,
9515 note_name, NT_S390_PREFIX, s390_prefix, size);
9516}
9517
355b81d9
UW
9518char *
9519elfcore_write_s390_last_break (bfd *abfd,
9520 char *buf,
9521 int *bufsiz,
9522 const void *s390_last_break,
9523 int size)
9524{
9525 char *note_name = "LINUX";
9526 return elfcore_write_note (abfd, buf, bufsiz,
9527 note_name, NT_S390_LAST_BREAK,
9528 s390_last_break, size);
9529}
9530
9531char *
9532elfcore_write_s390_system_call (bfd *abfd,
9533 char *buf,
9534 int *bufsiz,
9535 const void *s390_system_call,
9536 int size)
9537{
9538 char *note_name = "LINUX";
9539 return elfcore_write_note (abfd, buf, bufsiz,
9540 note_name, NT_S390_SYSTEM_CALL,
9541 s390_system_call, size);
9542}
9543
abb3f6cc
NC
9544char *
9545elfcore_write_s390_tdb (bfd *abfd,
9546 char *buf,
9547 int *bufsiz,
9548 const void *s390_tdb,
9549 int size)
9550{
9551 char *note_name = "LINUX";
9552 return elfcore_write_note (abfd, buf, bufsiz,
9553 note_name, NT_S390_TDB, s390_tdb, size);
9554}
9555
faa9a424
UW
9556char *
9557elfcore_write_arm_vfp (bfd *abfd,
9558 char *buf,
9559 int *bufsiz,
9560 const void *arm_vfp,
9561 int size)
9562{
9563 char *note_name = "LINUX";
9564 return elfcore_write_note (abfd, buf, bufsiz,
9565 note_name, NT_ARM_VFP, arm_vfp, size);
9566}
9567
652451f8
YZ
9568char *
9569elfcore_write_aarch_tls (bfd *abfd,
9570 char *buf,
9571 int *bufsiz,
9572 const void *aarch_tls,
9573 int size)
9574{
9575 char *note_name = "LINUX";
9576 return elfcore_write_note (abfd, buf, bufsiz,
9577 note_name, NT_ARM_TLS, aarch_tls, size);
9578}
9579
9580char *
9581elfcore_write_aarch_hw_break (bfd *abfd,
9582 char *buf,
9583 int *bufsiz,
9584 const void *aarch_hw_break,
9585 int size)
9586{
9587 char *note_name = "LINUX";
9588 return elfcore_write_note (abfd, buf, bufsiz,
9589 note_name, NT_ARM_HW_BREAK, aarch_hw_break, size);
9590}
9591
9592char *
9593elfcore_write_aarch_hw_watch (bfd *abfd,
9594 char *buf,
9595 int *bufsiz,
9596 const void *aarch_hw_watch,
9597 int size)
9598{
9599 char *note_name = "LINUX";
9600 return elfcore_write_note (abfd, buf, bufsiz,
9601 note_name, NT_ARM_HW_WATCH, aarch_hw_watch, size);
9602}
9603
bb864ac1
CES
9604char *
9605elfcore_write_register_note (bfd *abfd,
9606 char *buf,
9607 int *bufsiz,
9608 const char *section,
9609 const void *data,
9610 int size)
9611{
9612 if (strcmp (section, ".reg2") == 0)
9613 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
9614 if (strcmp (section, ".reg-xfp") == 0)
9615 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
4339cae0
L
9616 if (strcmp (section, ".reg-xstate") == 0)
9617 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
bb864ac1
CES
9618 if (strcmp (section, ".reg-ppc-vmx") == 0)
9619 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
89eeb0bc
LM
9620 if (strcmp (section, ".reg-ppc-vsx") == 0)
9621 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
0675e188
UW
9622 if (strcmp (section, ".reg-s390-high-gprs") == 0)
9623 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
d7eeb400
MS
9624 if (strcmp (section, ".reg-s390-timer") == 0)
9625 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
9626 if (strcmp (section, ".reg-s390-todcmp") == 0)
9627 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
9628 if (strcmp (section, ".reg-s390-todpreg") == 0)
9629 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
9630 if (strcmp (section, ".reg-s390-ctrs") == 0)
9631 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
9632 if (strcmp (section, ".reg-s390-prefix") == 0)
9633 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
355b81d9
UW
9634 if (strcmp (section, ".reg-s390-last-break") == 0)
9635 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
9636 if (strcmp (section, ".reg-s390-system-call") == 0)
9637 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
abb3f6cc
NC
9638 if (strcmp (section, ".reg-s390-tdb") == 0)
9639 return elfcore_write_s390_tdb (abfd, buf, bufsiz, data, size);
faa9a424
UW
9640 if (strcmp (section, ".reg-arm-vfp") == 0)
9641 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
652451f8
YZ
9642 if (strcmp (section, ".reg-aarch-tls") == 0)
9643 return elfcore_write_aarch_tls (abfd, buf, bufsiz, data, size);
9644 if (strcmp (section, ".reg-aarch-hw-break") == 0)
9645 return elfcore_write_aarch_hw_break (abfd, buf, bufsiz, data, size);
9646 if (strcmp (section, ".reg-aarch-hw-watch") == 0)
9647 return elfcore_write_aarch_hw_watch (abfd, buf, bufsiz, data, size);
bb864ac1
CES
9648 return NULL;
9649}
9650
b34976b6 9651static bfd_boolean
718175fa 9652elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
252b5132 9653{
c044fabd 9654 char *p;
252b5132 9655
252b5132
RH
9656 p = buf;
9657 while (p < buf + size)
9658 {
c044fabd
KH
9659 /* FIXME: bad alignment assumption. */
9660 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH
9661 Elf_Internal_Note in;
9662
baea7ef1
AM
9663 if (offsetof (Elf_External_Note, name) > buf - p + size)
9664 return FALSE;
9665
dc810e39 9666 in.type = H_GET_32 (abfd, xnp->type);
252b5132 9667
dc810e39 9668 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132 9669 in.namedata = xnp->name;
baea7ef1
AM
9670 if (in.namesz > buf - in.namedata + size)
9671 return FALSE;
252b5132 9672
dc810e39 9673 in.descsz = H_GET_32 (abfd, xnp->descsz);
252b5132
RH
9674 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
9675 in.descpos = offset + (in.descdata - buf);
baea7ef1
AM
9676 if (in.descsz != 0
9677 && (in.descdata >= buf + size
9678 || in.descsz > buf - in.descdata + size))
9679 return FALSE;
252b5132 9680
718175fa
JK
9681 switch (bfd_get_format (abfd))
9682 {
9683 default:
9684 return TRUE;
9685
9686 case bfd_core:
9687 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
9688 {
9689 if (! elfcore_grok_netbsd_note (abfd, &in))
9690 return FALSE;
9691 }
67cc5033
MK
9692 else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
9693 {
9694 if (! elfcore_grok_openbsd_note (abfd, &in))
9695 return FALSE;
9696 }
718175fa
JK
9697 else if (CONST_STRNEQ (in.namedata, "QNX"))
9698 {
9699 if (! elfcore_grok_nto_note (abfd, &in))
9700 return FALSE;
9701 }
b15fa79e
AM
9702 else if (CONST_STRNEQ (in.namedata, "SPU/"))
9703 {
9704 if (! elfcore_grok_spu_note (abfd, &in))
9705 return FALSE;
9706 }
718175fa
JK
9707 else
9708 {
9709 if (! elfcore_grok_note (abfd, &in))
9710 return FALSE;
9711 }
9712 break;
9713
9714 case bfd_object:
9715 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
9716 {
9717 if (! elfobj_grok_gnu_note (abfd, &in))
9718 return FALSE;
9719 }
e21e5835
NC
9720 else if (in.namesz == sizeof "stapsdt"
9721 && strcmp (in.namedata, "stapsdt") == 0)
9722 {
9723 if (! elfobj_grok_stapsdt_note (abfd, &in))
9724 return FALSE;
9725 }
718175fa 9726 break;
08a40648 9727 }
252b5132
RH
9728
9729 p = in.descdata + BFD_ALIGN (in.descsz, 4);
9730 }
9731
718175fa
JK
9732 return TRUE;
9733}
9734
9735static bfd_boolean
9736elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9737{
9738 char *buf;
9739
9740 if (size <= 0)
9741 return TRUE;
9742
9743 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9744 return FALSE;
9745
a50b1753 9746 buf = (char *) bfd_malloc (size);
718175fa
JK
9747 if (buf == NULL)
9748 return FALSE;
9749
9750 if (bfd_bread (buf, size, abfd) != size
9751 || !elf_parse_notes (abfd, buf, size, offset))
9752 {
9753 free (buf);
9754 return FALSE;
9755 }
9756
252b5132 9757 free (buf);
b34976b6 9758 return TRUE;
252b5132 9759}
98d8431c
JB
9760\f
9761/* Providing external access to the ELF program header table. */
9762
9763/* Return an upper bound on the number of bytes required to store a
9764 copy of ABFD's program header table entries. Return -1 if an error
9765 occurs; bfd_get_error will return an appropriate code. */
c044fabd 9766
98d8431c 9767long
217aa764 9768bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB
9769{
9770 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9771 {
9772 bfd_set_error (bfd_error_wrong_format);
9773 return -1;
9774 }
9775
936e320b 9776 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB
9777}
9778
98d8431c
JB
9779/* Copy ABFD's program header table entries to *PHDRS. The entries
9780 will be stored as an array of Elf_Internal_Phdr structures, as
9781 defined in include/elf/internal.h. To find out how large the
9782 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9783
9784 Return the number of program header table entries read, or -1 if an
9785 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 9786
98d8431c 9787int
217aa764 9788bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB
9789{
9790 int num_phdrs;
9791
9792 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9793 {
9794 bfd_set_error (bfd_error_wrong_format);
9795 return -1;
9796 }
9797
9798 num_phdrs = elf_elfheader (abfd)->e_phnum;
c044fabd 9799 memcpy (phdrs, elf_tdata (abfd)->phdr,
98d8431c
JB
9800 num_phdrs * sizeof (Elf_Internal_Phdr));
9801
9802 return num_phdrs;
9803}
ae4221d7 9804
db6751f2 9805enum elf_reloc_type_class
7e612e98
AM
9806_bfd_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
9807 const asection *rel_sec ATTRIBUTE_UNUSED,
9808 const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ
9809{
9810 return reloc_class_normal;
9811}
f8df10f4 9812
47d9a591 9813/* For RELA architectures, return the relocation value for a
f8df10f4
JJ
9814 relocation against a local symbol. */
9815
9816bfd_vma
217aa764
AM
9817_bfd_elf_rela_local_sym (bfd *abfd,
9818 Elf_Internal_Sym *sym,
8517fae7 9819 asection **psec,
217aa764 9820 Elf_Internal_Rela *rel)
f8df10f4 9821{
8517fae7 9822 asection *sec = *psec;
f8df10f4
JJ
9823 bfd_vma relocation;
9824
9825 relocation = (sec->output_section->vma
9826 + sec->output_offset
9827 + sym->st_value);
9828 if ((sec->flags & SEC_MERGE)
c629eae0 9829 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
dbaa2011 9830 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
f8df10f4 9831 {
f8df10f4 9832 rel->r_addend =
8517fae7 9833 _bfd_merged_section_offset (abfd, psec,
65765700 9834 elf_section_data (sec)->sec_info,
753731ee
AM
9835 sym->st_value + rel->r_addend);
9836 if (sec != *psec)
9837 {
9838 /* If we have changed the section, and our original section is
9839 marked with SEC_EXCLUDE, it means that the original
9840 SEC_MERGE section has been completely subsumed in some
9841 other SEC_MERGE section. In this case, we need to leave
9842 some info around for --emit-relocs. */
9843 if ((sec->flags & SEC_EXCLUDE) != 0)
9844 sec->kept_section = *psec;
9845 sec = *psec;
9846 }
8517fae7
AM
9847 rel->r_addend -= relocation;
9848 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ
9849 }
9850 return relocation;
9851}
c629eae0
JJ
9852
9853bfd_vma
217aa764
AM
9854_bfd_elf_rel_local_sym (bfd *abfd,
9855 Elf_Internal_Sym *sym,
9856 asection **psec,
9857 bfd_vma addend)
47d9a591 9858{
c629eae0
JJ
9859 asection *sec = *psec;
9860
dbaa2011 9861 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
c629eae0
JJ
9862 return sym->st_value + addend;
9863
9864 return _bfd_merged_section_offset (abfd, psec,
65765700 9865 elf_section_data (sec)->sec_info,
753731ee 9866 sym->st_value + addend);
c629eae0
JJ
9867}
9868
9869bfd_vma
217aa764 9870_bfd_elf_section_offset (bfd *abfd,
92e4ec35 9871 struct bfd_link_info *info,
217aa764
AM
9872 asection *sec,
9873 bfd_vma offset)
c629eae0 9874{
68bfbfcc 9875 switch (sec->sec_info_type)
65765700 9876 {
dbaa2011 9877 case SEC_INFO_TYPE_STABS:
eea6121a
AM
9878 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9879 offset);
dbaa2011 9880 case SEC_INFO_TYPE_EH_FRAME:
92e4ec35 9881 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
65765700 9882 default:
310fd250
L
9883 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
9884 {
9885 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9886 bfd_size_type address_size = bed->s->arch_size / 8;
9887 offset = sec->size - offset - address_size;
9888 }
65765700
JJ
9889 return offset;
9890 }
c629eae0 9891}
3333a7c3
RM
9892\f
9893/* Create a new BFD as if by bfd_openr. Rather than opening a file,
9894 reconstruct an ELF file by reading the segments out of remote memory
9895 based on the ELF file header at EHDR_VMA and the ELF program headers it
9896 points to. If not null, *LOADBASEP is filled in with the difference
9897 between the VMAs from which the segments were read, and the VMAs the
9898 file headers (and hence BFD's idea of each section's VMA) put them at.
9899
9900 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9901 remote memory at target address VMA into the local buffer at MYADDR; it
9902 should return zero on success or an `errno' code on failure. TEMPL must
9903 be a BFD for an ELF target with the word size and byte order found in
9904 the remote memory. */
9905
9906bfd *
217aa764
AM
9907bfd_elf_bfd_from_remote_memory
9908 (bfd *templ,
9909 bfd_vma ehdr_vma,
9910 bfd_vma *loadbasep,
fe78531d 9911 int (*target_read_memory) (bfd_vma, bfd_byte *, bfd_size_type))
3333a7c3
RM
9912{
9913 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9914 (templ, ehdr_vma, loadbasep, target_read_memory);
9915}
4c45e5c9
JJ
9916\f
9917long
c9727e01
AM
9918_bfd_elf_get_synthetic_symtab (bfd *abfd,
9919 long symcount ATTRIBUTE_UNUSED,
9920 asymbol **syms ATTRIBUTE_UNUSED,
8615f3f2 9921 long dynsymcount,
c9727e01
AM
9922 asymbol **dynsyms,
9923 asymbol **ret)
4c45e5c9
JJ
9924{
9925 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9926 asection *relplt;
9927 asymbol *s;
9928 const char *relplt_name;
9929 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9930 arelent *p;
9931 long count, i, n;
9932 size_t size;
9933 Elf_Internal_Shdr *hdr;
9934 char *names;
9935 asection *plt;
9936
8615f3f2
AM
9937 *ret = NULL;
9938
90e3cdf2
JJ
9939 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9940 return 0;
9941
8615f3f2
AM
9942 if (dynsymcount <= 0)
9943 return 0;
9944
4c45e5c9
JJ
9945 if (!bed->plt_sym_val)
9946 return 0;
9947
9948 relplt_name = bed->relplt_name;
9949 if (relplt_name == NULL)
d35fd659 9950 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
4c45e5c9
JJ
9951 relplt = bfd_get_section_by_name (abfd, relplt_name);
9952 if (relplt == NULL)
9953 return 0;
9954
9955 hdr = &elf_section_data (relplt)->this_hdr;
9956 if (hdr->sh_link != elf_dynsymtab (abfd)
9957 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9958 return 0;
9959
9960 plt = bfd_get_section_by_name (abfd, ".plt");
9961 if (plt == NULL)
9962 return 0;
9963
9964 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 9965 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ
9966 return -1;
9967
eea6121a 9968 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ
9969 size = count * sizeof (asymbol);
9970 p = relplt->relocation;
cb53bf42 9971 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
041de40d
AM
9972 {
9973 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9974 if (p->addend != 0)
9975 {
9976#ifdef BFD64
9977 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9978#else
9979 size += sizeof ("+0x") - 1 + 8;
9980#endif
9981 }
9982 }
4c45e5c9 9983
a50b1753 9984 s = *ret = (asymbol *) bfd_malloc (size);
4c45e5c9
JJ
9985 if (s == NULL)
9986 return -1;
9987
9988 names = (char *) (s + count);
9989 p = relplt->relocation;
9990 n = 0;
cb53bf42 9991 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
4c45e5c9
JJ
9992 {
9993 size_t len;
9994 bfd_vma addr;
9995
9996 addr = bed->plt_sym_val (i, plt, p);
9997 if (addr == (bfd_vma) -1)
9998 continue;
9999
10000 *s = **p->sym_ptr_ptr;
65a7a66f
AM
10001 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
10002 we are defining a symbol, ensure one of them is set. */
10003 if ((s->flags & BSF_LOCAL) == 0)
10004 s->flags |= BSF_GLOBAL;
6ba2a415 10005 s->flags |= BSF_SYNTHETIC;
4c45e5c9
JJ
10006 s->section = plt;
10007 s->value = addr - plt->vma;
10008 s->name = names;
8f39ba8e 10009 s->udata.p = NULL;
4c45e5c9
JJ
10010 len = strlen ((*p->sym_ptr_ptr)->name);
10011 memcpy (names, (*p->sym_ptr_ptr)->name, len);
10012 names += len;
041de40d
AM
10013 if (p->addend != 0)
10014 {
1d770845 10015 char buf[30], *a;
d324f6d6 10016
041de40d
AM
10017 memcpy (names, "+0x", sizeof ("+0x") - 1);
10018 names += sizeof ("+0x") - 1;
1d770845
L
10019 bfd_sprintf_vma (abfd, buf, p->addend);
10020 for (a = buf; *a == '0'; ++a)
10021 ;
10022 len = strlen (a);
10023 memcpy (names, a, len);
10024 names += len;
041de40d 10025 }
4c45e5c9
JJ
10026 memcpy (names, "@plt", sizeof ("@plt"));
10027 names += sizeof ("@plt");
8f39ba8e 10028 ++s, ++n;
4c45e5c9
JJ
10029 }
10030
10031 return n;
10032}
3d7f7666 10033
3b22753a
L
10034/* It is only used by x86-64 so far. */
10035asection _bfd_elf_large_com_section
10036 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
f592407e 10037 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
ecca9871 10038
d1036acb 10039void
78245035
L
10040_bfd_elf_post_process_headers (bfd * abfd,
10041 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
d1036acb
L
10042{
10043 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
10044
10045 i_ehdrp = elf_elfheader (abfd);
10046
10047 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
d8045f23
NC
10048
10049 /* To make things simpler for the loader on Linux systems we set the
9c55345c 10050 osabi field to ELFOSABI_GNU if the binary contains symbols of
f64b2e8d 10051 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
d8045f23 10052 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
f64b2e8d 10053 && elf_tdata (abfd)->has_gnu_symbols)
9c55345c 10054 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
d1036acb 10055}
fcb93ecf
PB
10056
10057
10058/* Return TRUE for ELF symbol types that represent functions.
10059 This is the default version of this function, which is sufficient for
d8045f23 10060 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
fcb93ecf
PB
10061
10062bfd_boolean
10063_bfd_elf_is_function_type (unsigned int type)
10064{
d8045f23
NC
10065 return (type == STT_FUNC
10066 || type == STT_GNU_IFUNC);
fcb93ecf 10067}
9f296da3 10068
aef36ac1
AM
10069/* If the ELF symbol SYM might be a function in SEC, return the
10070 function size and set *CODE_OFF to the function's entry point,
10071 otherwise return zero. */
9f296da3 10072
aef36ac1
AM
10073bfd_size_type
10074_bfd_elf_maybe_function_sym (const asymbol *sym, asection *sec,
10075 bfd_vma *code_off)
9f296da3 10076{
aef36ac1
AM
10077 bfd_size_type size;
10078
ff9e0f5b 10079 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
aef36ac1
AM
10080 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0
10081 || sym->section != sec)
10082 return 0;
ff9e0f5b 10083
ff9e0f5b 10084 *code_off = sym->value;
aef36ac1
AM
10085 size = 0;
10086 if (!(sym->flags & BSF_SYNTHETIC))
10087 size = ((elf_symbol_type *) sym)->internal_elf_sym.st_size;
10088 if (size == 0)
10089 size = 1;
10090 return size;
9f296da3 10091}
This page took 1.986331 seconds and 4 git commands to generate.