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