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