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