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