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