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