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