projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Handle R_X86_64_64 properly for x32
[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. */
dbaa2011 3074 if (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 4933 p->p_memsz = p->p_filesz;
2d16d28e
DK		 4934 /* Preserve the alignment and flags if they are valid. The gold
4935 linker generates RW/4 for the PT_GNU_RELRO section. It is better
4936 for objcopy/strip to honor these attributes otherwise gdb will
4937 choke when using separate debug files. */
4938 if (!m->p_align_valid)
4939 p->p_align = 1;
4940 if (!m->p_flags_valid)
4941 p->p_flags = (lp->p_flags & ~PF_W);
129af99f 4942 }
9433b9b1 4943 else
b84a33b5
AM		 4944 {
4945 memset (p, 0, sizeof *p);
4946 p->p_type = PT_NULL;
4947 }
129af99f
AS		 4948 }
4949 else if (m->count != 0)
4950 {
4951 if (p->p_type != PT_LOAD
4952 && (p->p_type != PT_NOTE
4953 || bfd_get_format (abfd) != bfd_core))
4954 {
129af99f
AS		 4955 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4956
86b2281f 4957 p->p_filesz = 0;
129af99f 4958 p->p_offset = m->sections[0]->filepos;
86b2281f
AM		 4959 for (i = m->count; i-- != 0;)
4960 {
4961 asection *sect = m->sections[i];
4962 Elf_Internal_Shdr *hdr = &elf_section_data (sect)->this_hdr;
4963 if (hdr->sh_type != SHT_NOBITS)
4964 {
4965 p->p_filesz = (sect->filepos - m->sections[0]->filepos
4966 + hdr->sh_size);
4967 break;
4968 }
4969 }
129af99f
AS		 4970 }
4971 }
4972 else if (m->includes_filehdr)
4973 {
4974 p->p_vaddr = filehdr_vaddr;
4975 if (! m->p_paddr_valid)
4976 p->p_paddr = filehdr_paddr;
4977 }
4978 else if (m->includes_phdrs)
4979 {
4980 p->p_vaddr = phdrs_vaddr;
4981 if (! m->p_paddr_valid)
4982 p->p_paddr = phdrs_paddr;
252b5132
RH		 4983 }
4984 }
4985
252b5132
RH		 4986 elf_tdata (abfd)->next_file_pos = off;
4987
b34976b6 4988 return TRUE;
252b5132
RH		 4989}
4990
252b5132
RH		 4991/* Work out the file positions of all the sections. This is called by
4992 _bfd_elf_compute_section_file_positions. All the section sizes and
4993 VMAs must be known before this is called.
4994
e0638f70
AM		 4995 Reloc sections come in two flavours: Those processed specially as
4996 "side-channel" data attached to a section to which they apply, and
4997 those that bfd doesn't process as relocations. The latter sort are
4998 stored in a normal bfd section by bfd_section_from_shdr. We don't
4999 consider the former sort here, unless they form part of the loadable
5000 image. Reloc sections not assigned here will be handled later by
5001 assign_file_positions_for_relocs.
252b5132
RH		 5002
5003 We also don't set the positions of the .symtab and .strtab here. */
5004
b34976b6 5005static bfd_boolean
c84fca4d
AO		 5006assign_file_positions_except_relocs (bfd *abfd,
5007 struct bfd_link_info *link_info)
252b5132 5008{
5c182d5f
AM		 5009 struct elf_obj_tdata *tdata = elf_tdata (abfd);
5010 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
252b5132 5011 file_ptr off;
9c5bfbb7 5012 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 5013
5014 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
5015 && bfd_get_format (abfd) != bfd_core)
5016 {
5c182d5f
AM		 5017 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
5018 unsigned int num_sec = elf_numsections (abfd);
252b5132
RH		 5019 Elf_Internal_Shdr **hdrpp;
5020 unsigned int i;
5021
5022 /* Start after the ELF header. */
5023 off = i_ehdrp->e_ehsize;
5024
5025 /* We are not creating an executable, which means that we are
5026 not creating a program header, and that the actual order of
5027 the sections in the file is unimportant. */
9ad5cbcf 5028 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH		 5029 {
5030 Elf_Internal_Shdr *hdr;
5031
5032 hdr = *hdrpp;
e0638f70
AM		 5033 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
5034 && hdr->bfd_section == NULL)
9ad5cbcf
AM		 5035 || i == tdata->symtab_section
5036 || i == tdata->symtab_shndx_section
252b5132
RH		 5037 || i == tdata->strtab_section)
5038 {
5039 hdr->sh_offset = -1;
252b5132 5040 }
9ad5cbcf 5041 else
b34976b6 5042 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132
RH		 5043 }
5044 }
5045 else
5046 {
f3520d2f
AM		 5047 unsigned int alloc;
5048
252b5132 5049 /* Assign file positions for the loaded sections based on the
08a40648 5050 assignment of sections to segments. */
f3520d2f
AM		 5051 if (!assign_file_positions_for_load_sections (abfd, link_info))
5052 return FALSE;
5053
5054 /* And for non-load sections. */
5055 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
5056 return FALSE;
5057
e36284ab
AM		 5058 if (bed->elf_backend_modify_program_headers != NULL)
5059 {
5060 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
5061 return FALSE;
5062 }
5063
f3520d2f
AM		 5064 /* Write out the program headers. */
5065 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
5066 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
5067 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
b34976b6 5068 return FALSE;
252b5132 5069
5c182d5f 5070 off = tdata->next_file_pos;
252b5132
RH		 5071 }
5072
5073 /* Place the section headers. */
45d6a902 5074 off = align_file_position (off, 1 << bed->s->log_file_align);
252b5132
RH		 5075 i_ehdrp->e_shoff = off;
5076 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
5077
5c182d5f 5078 tdata->next_file_pos = off;
252b5132 5079
b34976b6 5080 return TRUE;
252b5132
RH		 5081}
5082
b34976b6 5083static bfd_boolean
217aa764 5084prep_headers (bfd *abfd)
252b5132 5085{
3d540e93 5086 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form. */
2b0f7ef9 5087 struct elf_strtab_hash *shstrtab;
9c5bfbb7 5088 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 5089
5090 i_ehdrp = elf_elfheader (abfd);
252b5132 5091
2b0f7ef9 5092 shstrtab = _bfd_elf_strtab_init ();
252b5132 5093 if (shstrtab == NULL)
b34976b6 5094 return FALSE;
252b5132
RH		 5095
5096 elf_shstrtab (abfd) = shstrtab;
5097
5098 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
5099 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
5100 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
5101 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
5102
5103 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
5104 i_ehdrp->e_ident[EI_DATA] =
5105 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
5106 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
5107
252b5132
RH		 5108 if ((abfd->flags & DYNAMIC) != 0)
5109 i_ehdrp->e_type = ET_DYN;
5110 else if ((abfd->flags & EXEC_P) != 0)
5111 i_ehdrp->e_type = ET_EXEC;
5112 else if (bfd_get_format (abfd) == bfd_core)
5113 i_ehdrp->e_type = ET_CORE;
5114 else
5115 i_ehdrp->e_type = ET_REL;
5116
5117 switch (bfd_get_arch (abfd))
5118 {
5119 case bfd_arch_unknown:
5120 i_ehdrp->e_machine = EM_NONE;
5121 break;
aa4f99bb
AO		 5122
5123 /* There used to be a long list of cases here, each one setting
5124 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
5125 in the corresponding bfd definition. To avoid duplication,
5126 the switch was removed. Machines that need special handling
5127 can generally do it in elf_backend_final_write_processing(),
5128 unless they need the information earlier than the final write.
5129 Such need can generally be supplied by replacing the tests for
5130 e_machine with the conditions used to determine it. */
252b5132 5131 default:
9c5bfbb7
AM		 5132 i_ehdrp->e_machine = bed->elf_machine_code;
5133 }
aa4f99bb 5134
252b5132
RH		 5135 i_ehdrp->e_version = bed->s->ev_current;
5136 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
5137
c044fabd 5138 /* No program header, for now. */
252b5132
RH		 5139 i_ehdrp->e_phoff = 0;
5140 i_ehdrp->e_phentsize = 0;
5141 i_ehdrp->e_phnum = 0;
5142
c044fabd 5143 /* Each bfd section is section header entry. */
252b5132
RH		 5144 i_ehdrp->e_entry = bfd_get_start_address (abfd);
5145 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
5146
c044fabd 5147 /* If we're building an executable, we'll need a program header table. */
252b5132 5148 if (abfd->flags & EXEC_P)
0e71e495
BE		 5149 /* It all happens later. */
5150 ;
252b5132
RH		 5151 else
5152 {
5153 i_ehdrp->e_phentsize = 0;
252b5132
RH		 5154 i_ehdrp->e_phoff = 0;
5155 }
5156
5157 elf_tdata (abfd)->symtab_hdr.sh_name =
b34976b6 5158 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
252b5132 5159 elf_tdata (abfd)->strtab_hdr.sh_name =
b34976b6 5160 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
252b5132 5161 elf_tdata (abfd)->shstrtab_hdr.sh_name =
b34976b6 5162 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
252b5132
RH		 5163 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5164 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
5165 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
b34976b6 5166 return FALSE;
252b5132 5167
b34976b6 5168 return TRUE;
252b5132
RH		 5169}
5170
5171/* Assign file positions for all the reloc sections which are not part
5172 of the loadable file image. */
5173
5174void
217aa764 5175_bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
252b5132
RH		 5176{
5177 file_ptr off;
9ad5cbcf 5178 unsigned int i, num_sec;
252b5132
RH		 5179 Elf_Internal_Shdr **shdrpp;
5180
5181 off = elf_tdata (abfd)->next_file_pos;
5182
9ad5cbcf
AM		 5183 num_sec = elf_numsections (abfd);
5184 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
252b5132
RH		 5185 {
5186 Elf_Internal_Shdr *shdrp;
5187
5188 shdrp = *shdrpp;
5189 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
5190 && shdrp->sh_offset == -1)
b34976b6 5191 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
252b5132
RH		 5192 }
5193
5194 elf_tdata (abfd)->next_file_pos = off;
5195}
5196
b34976b6 5197bfd_boolean
217aa764 5198_bfd_elf_write_object_contents (bfd *abfd)
252b5132 5199{
9c5bfbb7 5200 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 5201 Elf_Internal_Shdr **i_shdrp;
b34976b6 5202 bfd_boolean failed;
9ad5cbcf 5203 unsigned int count, num_sec;
252b5132
RH		 5204
5205 if (! abfd->output_has_begun
217aa764 5206 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 5207 return FALSE;
252b5132
RH		 5208
5209 i_shdrp = elf_elfsections (abfd);
252b5132 5210
b34976b6 5211 failed = FALSE;
252b5132
RH		 5212 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
5213 if (failed)
b34976b6 5214 return FALSE;
252b5132
RH		 5215
5216 _bfd_elf_assign_file_positions_for_relocs (abfd);
5217
c044fabd 5218 /* After writing the headers, we need to write the sections too... */
9ad5cbcf
AM		 5219 num_sec = elf_numsections (abfd);
5220 for (count = 1; count < num_sec; count++)
252b5132
RH		 5221 {
5222 if (bed->elf_backend_section_processing)
5223 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
5224 if (i_shdrp[count]->contents)
5225 {
dc810e39
AM		 5226 bfd_size_type amt = i_shdrp[count]->sh_size;
5227
252b5132 5228 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
dc810e39 5229 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
b34976b6 5230 return FALSE;
252b5132
RH		 5231 }
5232 }
5233
5234 /* Write out the section header names. */
26ae6d5e
DJ		 5235 if (elf_shstrtab (abfd) != NULL
5236 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
08a40648 5237 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
b34976b6 5238 return FALSE;
252b5132
RH		 5239
5240 if (bed->elf_backend_final_write_processing)
5241 (*bed->elf_backend_final_write_processing) (abfd,
5242 elf_tdata (abfd)->linker);
5243
ff59fc36
RM		 5244 if (!bed->s->write_shdrs_and_ehdr (abfd))
5245 return FALSE;
5246
5247 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
bfb53a4f
RM		 5248 if (elf_tdata (abfd)->after_write_object_contents)
5249 return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
ff59fc36
RM		 5250
5251 return TRUE;
252b5132
RH		 5252}
5253
b34976b6 5254bfd_boolean
217aa764 5255_bfd_elf_write_corefile_contents (bfd *abfd)
252b5132 5256{
c044fabd 5257 /* Hopefully this can be done just like an object file. */
252b5132
RH		 5258 return _bfd_elf_write_object_contents (abfd);
5259}
c044fabd
KH		 5260
5261/* Given a section, search the header to find them. */
5262
cb33740c 5263unsigned int
198beae2 5264_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
252b5132 5265{
9c5bfbb7 5266 const struct elf_backend_data *bed;
91d6fa6a 5267 unsigned int sec_index;
252b5132 5268
9ad5cbcf
AM		 5269 if (elf_section_data (asect) != NULL
5270 && elf_section_data (asect)->this_idx != 0)
5271 return elf_section_data (asect)->this_idx;
5272
5273 if (bfd_is_abs_section (asect))
91d6fa6a 5274 sec_index = SHN_ABS;
af746e92 5275 else if (bfd_is_com_section (asect))
91d6fa6a 5276 sec_index = SHN_COMMON;
af746e92 5277 else if (bfd_is_und_section (asect))
91d6fa6a 5278 sec_index = SHN_UNDEF;
af746e92 5279 else
91d6fa6a 5280 sec_index = SHN_BAD;
252b5132 5281
af746e92 5282 bed = get_elf_backend_data (abfd);
252b5132
RH		 5283 if (bed->elf_backend_section_from_bfd_section)
5284 {
91d6fa6a 5285 int retval = sec_index;
9ad5cbcf 5286
af746e92
AM		 5287 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5288 return retval;
252b5132
RH		 5289 }
5290
91d6fa6a 5291 if (sec_index == SHN_BAD)
af746e92 5292 bfd_set_error (bfd_error_nonrepresentable_section);
252b5132 5293
91d6fa6a 5294 return sec_index;
252b5132
RH		 5295}
5296
5297/* Given a BFD symbol, return the index in the ELF symbol table, or -1
5298 on error. */
5299
5300int
217aa764 5301_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
252b5132
RH		 5302{
5303 asymbol *asym_ptr = *asym_ptr_ptr;
5304 int idx;
5305 flagword flags = asym_ptr->flags;
5306
5307 /* When gas creates relocations against local labels, it creates its
5308 own symbol for the section, but does put the symbol into the
5309 symbol chain, so udata is 0. When the linker is generating
5310 relocatable output, this section symbol may be for one of the
5311 input sections rather than the output section. */
5312 if (asym_ptr->udata.i == 0
5313 && (flags & BSF_SECTION_SYM)
5314 && asym_ptr->section)
5315 {
5372391b 5316 asection *sec;
252b5132
RH		 5317 int indx;
5318
5372391b
AM		 5319 sec = asym_ptr->section;
5320 if (sec->owner != abfd && sec->output_section != NULL)
5321 sec = sec->output_section;
5322 if (sec->owner == abfd
5323 && (indx = sec->index) < elf_num_section_syms (abfd)
4e89ac30 5324 && elf_section_syms (abfd)[indx] != NULL)
252b5132
RH		 5325 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5326 }
5327
5328 idx = asym_ptr->udata.i;
5329
5330 if (idx == 0)
5331 {
5332 /* This case can occur when using --strip-symbol on a symbol
08a40648 5333 which is used in a relocation entry. */
252b5132 5334 (*_bfd_error_handler)
d003868e
AM		 5335 (_("%B: symbol `%s' required but not present"),
5336 abfd, bfd_asymbol_name (asym_ptr));
252b5132
RH		 5337 bfd_set_error (bfd_error_no_symbols);
5338 return -1;
5339 }
5340
5341#if DEBUG & 4
5342 {
5343 fprintf (stderr,
9ccb8af9
AM		 5344 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx\n",
5345 (long) asym_ptr, asym_ptr->name, idx, (long) flags);
252b5132
RH		 5346 fflush (stderr);
5347 }
5348#endif
5349
5350 return idx;
5351}
5352
84d1d650 5353/* Rewrite program header information. */
252b5132 5354
b34976b6 5355static bfd_boolean
84d1d650 5356rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
252b5132 5357{
b34976b6
AM		 5358 Elf_Internal_Ehdr *iehdr;
5359 struct elf_segment_map *map;
5360 struct elf_segment_map *map_first;
5361 struct elf_segment_map **pointer_to_map;
5362 Elf_Internal_Phdr *segment;
5363 asection *section;
5364 unsigned int i;
5365 unsigned int num_segments;
5366 bfd_boolean phdr_included = FALSE;
5c44b38e 5367 bfd_boolean p_paddr_valid;
b34976b6
AM		 5368 bfd_vma maxpagesize;
5369 struct elf_segment_map *phdr_adjust_seg = NULL;
5370 unsigned int phdr_adjust_num = 0;
9c5bfbb7 5371 const struct elf_backend_data *bed;
bc67d8a6 5372
caf47ea6 5373 bed = get_elf_backend_data (ibfd);
252b5132
RH		 5374 iehdr = elf_elfheader (ibfd);
5375
bc67d8a6 5376 map_first = NULL;
c044fabd 5377 pointer_to_map = &map_first;
252b5132
RH		 5378
5379 num_segments = elf_elfheader (ibfd)->e_phnum;
bc67d8a6
NC		 5380 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5381
5382 /* Returns the end address of the segment + 1. */
aecc8f8a
AM		 5383#define SEGMENT_END(segment, start) \
5384 (start + (segment->p_memsz > segment->p_filesz \
5385 ? segment->p_memsz : segment->p_filesz))
bc67d8a6 5386
eecdbe52
JJ		 5387#define SECTION_SIZE(section, segment) \
5388 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5389 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
eea6121a 5390 ? section->size : 0)
eecdbe52 5391
b34976b6 5392 /* Returns TRUE if the given section is contained within
bc67d8a6 5393 the given segment. VMA addresses are compared. */
aecc8f8a
AM		 5394#define IS_CONTAINED_BY_VMA(section, segment) \
5395 (section->vma >= segment->p_vaddr \
eecdbe52 5396 && (section->vma + SECTION_SIZE (section, segment) \
aecc8f8a 5397 <= (SEGMENT_END (segment, segment->p_vaddr))))
c044fabd 5398
b34976b6 5399 /* Returns TRUE if the given section is contained within
bc67d8a6 5400 the given segment. LMA addresses are compared. */
aecc8f8a
AM		 5401#define IS_CONTAINED_BY_LMA(section, segment, base) \
5402 (section->lma >= base \
eecdbe52 5403 && (section->lma + SECTION_SIZE (section, segment) \
aecc8f8a 5404 <= SEGMENT_END (segment, base)))
252b5132 5405
0efc80c8
L		 5406 /* Handle PT_NOTE segment. */
5407#define IS_NOTE(p, s) \
aecc8f8a 5408 (p->p_type == PT_NOTE \
0efc80c8 5409 && elf_section_type (s) == SHT_NOTE \
aecc8f8a 5410 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 5411 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 5412 <= p->p_offset + p->p_filesz))
252b5132 5413
0efc80c8
L		 5414 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5415 etc. */
5416#define IS_COREFILE_NOTE(p, s) \
5417 (IS_NOTE (p, s) \
5418 && bfd_get_format (ibfd) == bfd_core \
5419 && s->vma == 0 \
5420 && s->lma == 0)
5421
252b5132
RH		 5422 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5423 linker, which generates a PT_INTERP section with p_vaddr and
5424 p_memsz set to 0. */
aecc8f8a
AM		 5425#define IS_SOLARIS_PT_INTERP(p, s) \
5426 (p->p_vaddr == 0 \
5427 && p->p_paddr == 0 \
5428 && p->p_memsz == 0 \
5429 && p->p_filesz > 0 \
5430 && (s->flags & SEC_HAS_CONTENTS) != 0 \
eea6121a 5431 && s->size > 0 \
aecc8f8a 5432 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 5433 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 5434 <= p->p_offset + p->p_filesz))
5c440b1e 5435
bc67d8a6
NC		 5436 /* Decide if the given section should be included in the given segment.
5437 A section will be included if:
f5ffc919 5438 1. It is within the address space of the segment -- we use the LMA
08a40648 5439 if that is set for the segment and the VMA otherwise,
0efc80c8 5440 2. It is an allocated section or a NOTE section in a PT_NOTE
d324f6d6 5441 segment.
bc67d8a6 5442 3. There is an output section associated with it,
eecdbe52 5443 4. The section has not already been allocated to a previous segment.
2b05f1b7 5444 5. PT_GNU_STACK segments do not include any sections.
03394ac9 5445 6. PT_TLS segment includes only SHF_TLS sections.
6f79b219
JJ		 5446 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5447 8. PT_DYNAMIC should not contain empty sections at the beginning
08a40648 5448 (with the possible exception of .dynamic). */
9f17e2a6 5449#define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
2b05f1b7
L		 5450 ((((segment->p_paddr \
5451 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5452 : IS_CONTAINED_BY_VMA (section, segment)) \
5453 && (section->flags & SEC_ALLOC) != 0) \
0efc80c8 5454 || IS_NOTE (segment, section)) \
2b05f1b7
L		 5455 && segment->p_type != PT_GNU_STACK \
5456 && (segment->p_type != PT_TLS \
5457 || (section->flags & SEC_THREAD_LOCAL)) \
5458 && (segment->p_type == PT_LOAD \
5459 || segment->p_type == PT_TLS \
5460 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5461 && (segment->p_type != PT_DYNAMIC \
5462 || SECTION_SIZE (section, segment) > 0 \
5463 || (segment->p_paddr \
5464 ? segment->p_paddr != section->lma \
5465 : segment->p_vaddr != section->vma) \
5466 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5467 == 0)) \
0067a569 5468 && !section->segment_mark)
bc67d8a6 5469
9f17e2a6
L		 5470/* If the output section of a section in the input segment is NULL,
5471 it is removed from the corresponding output segment. */
5472#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5473 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5474 && section->output_section != NULL)
5475
b34976b6 5476 /* Returns TRUE iff seg1 starts after the end of seg2. */
b5f852ea
NC		 5477#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5478 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5479
5480 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5481 their VMA address ranges and their LMA address ranges overlap.
5482 It is possible to have overlapping VMA ranges without overlapping LMA
5483 ranges. RedBoot images for example can have both .data and .bss mapped
5484 to the same VMA range, but with the .data section mapped to a different
5485 LMA. */
aecc8f8a 5486#define SEGMENT_OVERLAPS(seg1, seg2) \
b5f852ea 5487 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
08a40648 5488 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
b5f852ea 5489 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
08a40648 5490 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
bc67d8a6
NC		 5491
5492 /* Initialise the segment mark field. */
5493 for (section = ibfd->sections; section != NULL; section = section->next)
b34976b6 5494 section->segment_mark = FALSE;
bc67d8a6 5495
5c44b38e
AM		 5496 /* The Solaris linker creates program headers in which all the
5497 p_paddr fields are zero. When we try to objcopy or strip such a
5498 file, we get confused. Check for this case, and if we find it
5499 don't set the p_paddr_valid fields. */
5500 p_paddr_valid = FALSE;
5501 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5502 i < num_segments;
5503 i++, segment++)
5504 if (segment->p_paddr != 0)
5505 {
5506 p_paddr_valid = TRUE;
5507 break;
5508 }
5509
252b5132 5510 /* Scan through the segments specified in the program header
bc67d8a6 5511 of the input BFD. For this first scan we look for overlaps
9ad5cbcf 5512 in the loadable segments. These can be created by weird
aecc8f8a 5513 parameters to objcopy. Also, fix some solaris weirdness. */
bc67d8a6
NC		 5514 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5515 i < num_segments;
c044fabd 5516 i++, segment++)
252b5132 5517 {
252b5132 5518 unsigned int j;
c044fabd 5519 Elf_Internal_Phdr *segment2;
252b5132 5520
aecc8f8a
AM		 5521 if (segment->p_type == PT_INTERP)
5522 for (section = ibfd->sections; section; section = section->next)
5523 if (IS_SOLARIS_PT_INTERP (segment, section))
5524 {
5525 /* Mininal change so that the normal section to segment
4cc11e76 5526 assignment code will work. */
aecc8f8a
AM		 5527 segment->p_vaddr = section->vma;
5528 break;
5529 }
5530
bc67d8a6 5531 if (segment->p_type != PT_LOAD)
b10a8ae0
L		 5532 {
5533 /* Remove PT_GNU_RELRO segment. */
5534 if (segment->p_type == PT_GNU_RELRO)
5535 segment->p_type = PT_NULL;
5536 continue;
5537 }
c044fabd 5538
bc67d8a6 5539 /* Determine if this segment overlaps any previous segments. */
0067a569 5540 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
bc67d8a6
NC		 5541 {
5542 bfd_signed_vma extra_length;
c044fabd 5543
bc67d8a6 5544 if (segment2->p_type != PT_LOAD
0067a569 5545 || !SEGMENT_OVERLAPS (segment, segment2))
bc67d8a6 5546 continue;
c044fabd 5547
bc67d8a6
NC		 5548 /* Merge the two segments together. */
5549 if (segment2->p_vaddr < segment->p_vaddr)
5550 {
c044fabd 5551 /* Extend SEGMENT2 to include SEGMENT and then delete
08a40648 5552 SEGMENT. */
0067a569
AM		 5553 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5554 - SEGMENT_END (segment2, segment2->p_vaddr));
c044fabd 5555
bc67d8a6
NC		 5556 if (extra_length > 0)
5557 {
0067a569 5558 segment2->p_memsz += extra_length;
bc67d8a6
NC		 5559 segment2->p_filesz += extra_length;
5560 }
c044fabd 5561
bc67d8a6 5562 segment->p_type = PT_NULL;
c044fabd 5563
bc67d8a6
NC		 5564 /* Since we have deleted P we must restart the outer loop. */
5565 i = 0;
5566 segment = elf_tdata (ibfd)->phdr;
5567 break;
5568 }
5569 else
5570 {
c044fabd 5571 /* Extend SEGMENT to include SEGMENT2 and then delete
08a40648 5572 SEGMENT2. */
0067a569
AM		 5573 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5574 - SEGMENT_END (segment, segment->p_vaddr));
c044fabd 5575
bc67d8a6
NC		 5576 if (extra_length > 0)
5577 {
0067a569 5578 segment->p_memsz += extra_length;
bc67d8a6
NC		 5579 segment->p_filesz += extra_length;
5580 }
c044fabd 5581
bc67d8a6
NC		 5582 segment2->p_type = PT_NULL;
5583 }
5584 }
5585 }
c044fabd 5586
bc67d8a6
NC		 5587 /* The second scan attempts to assign sections to segments. */
5588 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5589 i < num_segments;
0067a569 5590 i++, segment++)
bc67d8a6 5591 {
0067a569
AM		 5592 unsigned int section_count;
5593 asection **sections;
5594 asection *output_section;
5595 unsigned int isec;
5596 bfd_vma matching_lma;
5597 bfd_vma suggested_lma;
5598 unsigned int j;
dc810e39 5599 bfd_size_type amt;
0067a569
AM		 5600 asection *first_section;
5601 bfd_boolean first_matching_lma;
5602 bfd_boolean first_suggested_lma;
bc67d8a6
NC		 5603
5604 if (segment->p_type == PT_NULL)
5605 continue;
c044fabd 5606
9f17e2a6 5607 first_section = NULL;
bc67d8a6 5608 /* Compute how many sections might be placed into this segment. */
b5f852ea
NC		 5609 for (section = ibfd->sections, section_count = 0;
5610 section != NULL;
5611 section = section->next)
9f17e2a6
L		 5612 {
5613 /* Find the first section in the input segment, which may be
5614 removed from the corresponding output segment. */
5615 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5616 {
5617 if (first_section == NULL)
5618 first_section = section;
5619 if (section->output_section != NULL)
5620 ++section_count;
5621 }
5622 }
811072d8 5623
b5f852ea
NC		 5624 /* Allocate a segment map big enough to contain
5625 all of the sections we have selected. */
dc810e39
AM		 5626 amt = sizeof (struct elf_segment_map);
5627 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
a50b1753 5628 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
bc67d8a6 5629 if (map == NULL)
b34976b6 5630 return FALSE;
252b5132
RH		 5631
5632 /* Initialise the fields of the segment map. Default to
5633 using the physical address of the segment in the input BFD. */
0067a569
AM		 5634 map->next = NULL;
5635 map->p_type = segment->p_type;
5636 map->p_flags = segment->p_flags;
bc67d8a6 5637 map->p_flags_valid = 1;
55d55ac7 5638
9f17e2a6
L		 5639 /* If the first section in the input segment is removed, there is
5640 no need to preserve segment physical address in the corresponding
5641 output segment. */
945c025a 5642 if (!first_section || first_section->output_section != NULL)
9f17e2a6
L		 5643 {
5644 map->p_paddr = segment->p_paddr;
5c44b38e 5645 map->p_paddr_valid = p_paddr_valid;
9f17e2a6 5646 }
252b5132
RH		 5647
5648 /* Determine if this segment contains the ELF file header
5649 and if it contains the program headers themselves. */
bc67d8a6
NC		 5650 map->includes_filehdr = (segment->p_offset == 0
5651 && segment->p_filesz >= iehdr->e_ehsize);
bc67d8a6 5652 map->includes_phdrs = 0;
252b5132 5653
0067a569 5654 if (!phdr_included || segment->p_type != PT_LOAD)
252b5132 5655 {
bc67d8a6
NC		 5656 map->includes_phdrs =
5657 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5658 && (segment->p_offset + segment->p_filesz
252b5132
RH		 5659 >= ((bfd_vma) iehdr->e_phoff
5660 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 5661
bc67d8a6 5662 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 5663 phdr_included = TRUE;
252b5132
RH		 5664 }
5665
bc67d8a6 5666 if (section_count == 0)
252b5132
RH		 5667 {
5668 /* Special segments, such as the PT_PHDR segment, may contain
5669 no sections, but ordinary, loadable segments should contain
1ed89aa9
NC		 5670 something. They are allowed by the ELF spec however, so only
5671 a warning is produced. */
bc67d8a6 5672 if (segment->p_type == PT_LOAD)
0067a569
AM		 5673 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5674 " detected, is this intentional ?\n"),
5675 ibfd);
252b5132 5676
bc67d8a6 5677 map->count = 0;
c044fabd
KH		 5678 *pointer_to_map = map;
5679 pointer_to_map = &map->next;
252b5132
RH		 5680
5681 continue;
5682 }
5683
5684 /* Now scan the sections in the input BFD again and attempt
5685 to add their corresponding output sections to the segment map.
5686 The problem here is how to handle an output section which has
5687 been moved (ie had its LMA changed). There are four possibilities:
5688
5689 1. None of the sections have been moved.
5690 In this case we can continue to use the segment LMA from the
5691 input BFD.
5692
5693 2. All of the sections have been moved by the same amount.
5694 In this case we can change the segment's LMA to match the LMA
5695 of the first section.
5696
5697 3. Some of the sections have been moved, others have not.
5698 In this case those sections which have not been moved can be
5699 placed in the current segment which will have to have its size,
5700 and possibly its LMA changed, and a new segment or segments will
5701 have to be created to contain the other sections.
5702
b5f852ea 5703 4. The sections have been moved, but not by the same amount.
252b5132
RH		 5704 In this case we can change the segment's LMA to match the LMA
5705 of the first section and we will have to create a new segment
5706 or segments to contain the other sections.
5707
5708 In order to save time, we allocate an array to hold the section
5709 pointers that we are interested in. As these sections get assigned
5710 to a segment, they are removed from this array. */
5711
a50b1753 5712 sections = (asection **) bfd_malloc2 (section_count, sizeof (asection *));
252b5132 5713 if (sections == NULL)
b34976b6 5714 return FALSE;
252b5132
RH		 5715
5716 /* Step One: Scan for segment vs section LMA conflicts.
5717 Also add the sections to the section array allocated above.
5718 Also add the sections to the current segment. In the common
5719 case, where the sections have not been moved, this means that
5720 we have completely filled the segment, and there is nothing
5721 more to do. */
252b5132 5722 isec = 0;
72730e0c 5723 matching_lma = 0;
252b5132 5724 suggested_lma = 0;
0067a569
AM		 5725 first_matching_lma = TRUE;
5726 first_suggested_lma = TRUE;
252b5132 5727
147d51c2 5728 for (section = ibfd->sections;
bc67d8a6
NC		 5729 section != NULL;
5730 section = section->next)
147d51c2
L		 5731 if (section == first_section)
5732 break;
5733
5734 for (j = 0; section != NULL; section = section->next)
252b5132 5735 {
caf47ea6 5736 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 5737 {
bc67d8a6
NC		 5738 output_section = section->output_section;
5739
0067a569 5740 sections[j++] = section;
252b5132
RH		 5741
5742 /* The Solaris native linker always sets p_paddr to 0.
5743 We try to catch that case here, and set it to the
5e8d7549
NC		 5744 correct value. Note - some backends require that
5745 p_paddr be left as zero. */
5c44b38e 5746 if (!p_paddr_valid
4455705d 5747 && segment->p_vaddr != 0
0067a569 5748 && !bed->want_p_paddr_set_to_zero
252b5132 5749 && isec == 0
bc67d8a6 5750 && output_section->lma != 0
0067a569
AM		 5751 && output_section->vma == (segment->p_vaddr
5752 + (map->includes_filehdr
5753 ? iehdr->e_ehsize
5754 : 0)
5755 + (map->includes_phdrs
5756 ? (iehdr->e_phnum
5757 * iehdr->e_phentsize)
5758 : 0)))
bc67d8a6 5759 map->p_paddr = segment->p_vaddr;
252b5132
RH		 5760
5761 /* Match up the physical address of the segment with the
5762 LMA address of the output section. */
bc67d8a6 5763 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549 5764 || IS_COREFILE_NOTE (segment, section)
0067a569
AM		 5765 || (bed->want_p_paddr_set_to_zero
5766 && IS_CONTAINED_BY_VMA (output_section, segment)))
252b5132 5767 {
0067a569
AM		 5768 if (first_matching_lma || output_section->lma < matching_lma)
5769 {
5770 matching_lma = output_section->lma;
5771 first_matching_lma = FALSE;
5772 }
252b5132
RH		 5773
5774 /* We assume that if the section fits within the segment
bc67d8a6 5775 then it does not overlap any other section within that
252b5132 5776 segment. */
0067a569
AM		 5777 map->sections[isec++] = output_section;
5778 }
5779 else if (first_suggested_lma)
5780 {
5781 suggested_lma = output_section->lma;
5782 first_suggested_lma = FALSE;
252b5132 5783 }
147d51c2
L		 5784
5785 if (j == section_count)
5786 break;
252b5132
RH		 5787 }
5788 }
5789
bc67d8a6 5790 BFD_ASSERT (j == section_count);
252b5132
RH		 5791
5792 /* Step Two: Adjust the physical address of the current segment,
5793 if necessary. */
bc67d8a6 5794 if (isec == section_count)
252b5132
RH		 5795 {
5796 /* All of the sections fitted within the segment as currently
5797 specified. This is the default case. Add the segment to
5798 the list of built segments and carry on to process the next
5799 program header in the input BFD. */
bc67d8a6 5800 map->count = section_count;
c044fabd
KH		 5801 *pointer_to_map = map;
5802 pointer_to_map = &map->next;
08a40648 5803
5c44b38e
AM		 5804 if (p_paddr_valid
5805 && !bed->want_p_paddr_set_to_zero
147d51c2 5806 && matching_lma != map->p_paddr
5c44b38e
AM		 5807 && !map->includes_filehdr
5808 && !map->includes_phdrs)
3271a814
NS		 5809 /* There is some padding before the first section in the
5810 segment. So, we must account for that in the output
5811 segment's vma. */
5812 map->p_vaddr_offset = matching_lma - map->p_paddr;
08a40648 5813
252b5132
RH		 5814 free (sections);
5815 continue;
5816 }
252b5132
RH		 5817 else
5818 {
0067a569 5819 if (!first_matching_lma)
72730e0c
AM		 5820 {
5821 /* At least one section fits inside the current segment.
5822 Keep it, but modify its physical address to match the
5823 LMA of the first section that fitted. */
bc67d8a6 5824 map->p_paddr = matching_lma;
72730e0c
AM		 5825 }
5826 else
5827 {
5828 /* None of the sections fitted inside the current segment.
5829 Change the current segment's physical address to match
5830 the LMA of the first section. */
bc67d8a6 5831 map->p_paddr = suggested_lma;
72730e0c
AM		 5832 }
5833
bc67d8a6
NC		 5834 /* Offset the segment physical address from the lma
5835 to allow for space taken up by elf headers. */
5836 if (map->includes_filehdr)
010c8431
AM		 5837 {
5838 if (map->p_paddr >= iehdr->e_ehsize)
5839 map->p_paddr -= iehdr->e_ehsize;
5840 else
5841 {
5842 map->includes_filehdr = FALSE;
5843 map->includes_phdrs = FALSE;
5844 }
5845 }
252b5132 5846
bc67d8a6
NC		 5847 if (map->includes_phdrs)
5848 {
010c8431
AM		 5849 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5850 {
5851 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5852
5853 /* iehdr->e_phnum is just an estimate of the number
5854 of program headers that we will need. Make a note
5855 here of the number we used and the segment we chose
5856 to hold these headers, so that we can adjust the
5857 offset when we know the correct value. */
5858 phdr_adjust_num = iehdr->e_phnum;
5859 phdr_adjust_seg = map;
5860 }
5861 else
5862 map->includes_phdrs = FALSE;
bc67d8a6 5863 }
252b5132
RH		 5864 }
5865
5866 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 5867 those that fit to the current segment and removing them from the
252b5132
RH		 5868 sections array; but making sure not to leave large gaps. Once all
5869 possible sections have been assigned to the current segment it is
5870 added to the list of built segments and if sections still remain
5871 to be assigned, a new segment is constructed before repeating
5872 the loop. */
5873 isec = 0;
5874 do
5875 {
bc67d8a6 5876 map->count = 0;
252b5132 5877 suggested_lma = 0;
0067a569 5878 first_suggested_lma = TRUE;
252b5132
RH		 5879
5880 /* Fill the current segment with sections that fit. */
bc67d8a6 5881 for (j = 0; j < section_count; j++)
252b5132 5882 {
bc67d8a6 5883 section = sections[j];
252b5132 5884
bc67d8a6 5885 if (section == NULL)
252b5132
RH		 5886 continue;
5887
bc67d8a6 5888 output_section = section->output_section;
252b5132 5889
bc67d8a6 5890 BFD_ASSERT (output_section != NULL);
c044fabd 5891
bc67d8a6
NC		 5892 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5893 || IS_COREFILE_NOTE (segment, section))
252b5132 5894 {
bc67d8a6 5895 if (map->count == 0)
252b5132
RH		 5896 {
5897 /* If the first section in a segment does not start at
bc67d8a6
NC		 5898 the beginning of the segment, then something is
5899 wrong. */
0067a569
AM		 5900 if (output_section->lma
5901 != (map->p_paddr
5902 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5903 + (map->includes_phdrs
5904 ? iehdr->e_phnum * iehdr->e_phentsize
5905 : 0)))
252b5132
RH		 5906 abort ();
5907 }
5908 else
5909 {
0067a569 5910 asection *prev_sec;
252b5132 5911
bc67d8a6 5912 prev_sec = map->sections[map->count - 1];
252b5132
RH		 5913
5914 /* If the gap between the end of the previous section
bc67d8a6
NC		 5915 and the start of this section is more than
5916 maxpagesize then we need to start a new segment. */
eea6121a 5917 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 5918 maxpagesize)
caf47ea6 5919 < BFD_ALIGN (output_section->lma, maxpagesize))
0067a569 5920 || (prev_sec->lma + prev_sec->size
079e9a2f 5921 > output_section->lma))
252b5132 5922 {
0067a569
AM		 5923 if (first_suggested_lma)
5924 {
5925 suggested_lma = output_section->lma;
5926 first_suggested_lma = FALSE;
5927 }
252b5132
RH		 5928
5929 continue;
5930 }
5931 }
5932
bc67d8a6 5933 map->sections[map->count++] = output_section;
252b5132
RH		 5934 ++isec;
5935 sections[j] = NULL;
b34976b6 5936 section->segment_mark = TRUE;
252b5132 5937 }
0067a569
AM		 5938 else if (first_suggested_lma)
5939 {
5940 suggested_lma = output_section->lma;
5941 first_suggested_lma = FALSE;
5942 }
252b5132
RH		 5943 }
5944
bc67d8a6 5945 BFD_ASSERT (map->count > 0);
252b5132
RH		 5946
5947 /* Add the current segment to the list of built segments. */
c044fabd
KH		 5948 *pointer_to_map = map;
5949 pointer_to_map = &map->next;
252b5132 5950
bc67d8a6 5951 if (isec < section_count)
252b5132
RH		 5952 {
5953 /* We still have not allocated all of the sections to
5954 segments. Create a new segment here, initialise it
5955 and carry on looping. */
dc810e39
AM		 5956 amt = sizeof (struct elf_segment_map);
5957 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
a50b1753 5958 map = (struct elf_segment_map *) bfd_alloc (obfd, amt);
bc67d8a6 5959 if (map == NULL)
5ed6aba4
NC		 5960 {
5961 free (sections);
5962 return FALSE;
5963 }
252b5132
RH		 5964
5965 /* Initialise the fields of the segment map. Set the physical
5966 physical address to the LMA of the first section that has
5967 not yet been assigned. */
0067a569
AM		 5968 map->next = NULL;
5969 map->p_type = segment->p_type;
5970 map->p_flags = segment->p_flags;
5971 map->p_flags_valid = 1;
5972 map->p_paddr = suggested_lma;
5c44b38e 5973 map->p_paddr_valid = p_paddr_valid;
bc67d8a6 5974 map->includes_filehdr = 0;
0067a569 5975 map->includes_phdrs = 0;
252b5132
RH		 5976 }
5977 }
bc67d8a6 5978 while (isec < section_count);
252b5132
RH		 5979
5980 free (sections);
5981 }
5982
bc67d8a6
NC		 5983 elf_tdata (obfd)->segment_map = map_first;
5984
5985 /* If we had to estimate the number of program headers that were
9ad5cbcf 5986 going to be needed, then check our estimate now and adjust
bc67d8a6
NC		 5987 the offset if necessary. */
5988 if (phdr_adjust_seg != NULL)
5989 {
5990 unsigned int count;
c044fabd 5991
bc67d8a6 5992 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 5993 count++;
252b5132 5994
bc67d8a6
NC		 5995 if (count > phdr_adjust_num)
5996 phdr_adjust_seg->p_paddr
5997 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5998 }
c044fabd 5999
bc67d8a6 6000#undef SEGMENT_END
eecdbe52 6001#undef SECTION_SIZE
bc67d8a6
NC		 6002#undef IS_CONTAINED_BY_VMA
6003#undef IS_CONTAINED_BY_LMA
0efc80c8 6004#undef IS_NOTE
252b5132 6005#undef IS_COREFILE_NOTE
bc67d8a6 6006#undef IS_SOLARIS_PT_INTERP
9f17e2a6 6007#undef IS_SECTION_IN_INPUT_SEGMENT
bc67d8a6
NC		 6008#undef INCLUDE_SECTION_IN_SEGMENT
6009#undef SEGMENT_AFTER_SEGMENT
6010#undef SEGMENT_OVERLAPS
b34976b6 6011 return TRUE;
252b5132
RH		 6012}
6013
84d1d650
L		 6014/* Copy ELF program header information. */
6015
6016static bfd_boolean
6017copy_elf_program_header (bfd *ibfd, bfd *obfd)
6018{
6019 Elf_Internal_Ehdr *iehdr;
6020 struct elf_segment_map *map;
6021 struct elf_segment_map *map_first;
6022 struct elf_segment_map **pointer_to_map;
6023 Elf_Internal_Phdr *segment;
6024 unsigned int i;
6025 unsigned int num_segments;
6026 bfd_boolean phdr_included = FALSE;
88967714 6027 bfd_boolean p_paddr_valid;
84d1d650
L		 6028
6029 iehdr = elf_elfheader (ibfd);
6030
6031 map_first = NULL;
6032 pointer_to_map = &map_first;
6033
88967714
AM		 6034 /* If all the segment p_paddr fields are zero, don't set
6035 map->p_paddr_valid. */
6036 p_paddr_valid = FALSE;
84d1d650 6037 num_segments = elf_elfheader (ibfd)->e_phnum;
88967714
AM		 6038 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6039 i < num_segments;
6040 i++, segment++)
6041 if (segment->p_paddr != 0)
6042 {
6043 p_paddr_valid = TRUE;
6044 break;
6045 }
6046
84d1d650
L		 6047 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6048 i < num_segments;
6049 i++, segment++)
6050 {
6051 asection *section;
6052 unsigned int section_count;
6053 bfd_size_type amt;
6054 Elf_Internal_Shdr *this_hdr;
53020534 6055 asection *first_section = NULL;
a76e6f2f 6056 asection *lowest_section;
84d1d650 6057
84d1d650
L		 6058 /* Compute how many sections are in this segment. */
6059 for (section = ibfd->sections, section_count = 0;
6060 section != NULL;
6061 section = section->next)
6062 {
6063 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 6064 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
3271a814 6065 {
a76e6f2f
AM		 6066 if (first_section == NULL)
6067 first_section = section;
3271a814
NS		 6068 section_count++;
6069 }
84d1d650
L		 6070 }
6071
6072 /* Allocate a segment map big enough to contain
6073 all of the sections we have selected. */
6074 amt = sizeof (struct elf_segment_map);
6075 if (section_count != 0)
6076 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
a50b1753 6077 map = (struct elf_segment_map *) bfd_zalloc (obfd, amt);
84d1d650
L		 6078 if (map == NULL)
6079 return FALSE;
6080
6081 /* Initialize the fields of the output segment map with the
6082 input segment. */
6083 map->next = NULL;
6084 map->p_type = segment->p_type;
6085 map->p_flags = segment->p_flags;
6086 map->p_flags_valid = 1;
6087 map->p_paddr = segment->p_paddr;
88967714 6088 map->p_paddr_valid = p_paddr_valid;
3f570048
AM		 6089 map->p_align = segment->p_align;
6090 map->p_align_valid = 1;
3271a814 6091 map->p_vaddr_offset = 0;
84d1d650 6092
9433b9b1 6093 if (map->p_type == PT_GNU_RELRO)
b10a8ae0
L		 6094 {
6095 /* The PT_GNU_RELRO segment may contain the first a few
6096 bytes in the .got.plt section even if the whole .got.plt
6097 section isn't in the PT_GNU_RELRO segment. We won't
6098 change the size of the PT_GNU_RELRO segment. */
9433b9b1 6099 map->p_size = segment->p_memsz;
b10a8ae0
L		 6100 map->p_size_valid = 1;
6101 }
6102
84d1d650
L		 6103 /* Determine if this segment contains the ELF file header
6104 and if it contains the program headers themselves. */
6105 map->includes_filehdr = (segment->p_offset == 0
6106 && segment->p_filesz >= iehdr->e_ehsize);
6107
6108 map->includes_phdrs = 0;
6109 if (! phdr_included || segment->p_type != PT_LOAD)
6110 {
6111 map->includes_phdrs =
6112 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
6113 && (segment->p_offset + segment->p_filesz
6114 >= ((bfd_vma) iehdr->e_phoff
6115 + iehdr->e_phnum * iehdr->e_phentsize)));
6116
6117 if (segment->p_type == PT_LOAD && map->includes_phdrs)
6118 phdr_included = TRUE;
6119 }
6120
a76e6f2f 6121 lowest_section = first_section;
84d1d650
L		 6122 if (section_count != 0)
6123 {
6124 unsigned int isec = 0;
6125
53020534 6126 for (section = first_section;
84d1d650
L		 6127 section != NULL;
6128 section = section->next)
6129 {
6130 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 6131 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
53020534
L		 6132 {
6133 map->sections[isec++] = section->output_section;
a76e6f2f
AM		 6134 if (section->lma < lowest_section->lma)
6135 lowest_section = section;
6136 if ((section->flags & SEC_ALLOC) != 0)
6137 {
6138 bfd_vma seg_off;
6139
6140 /* Section lmas are set up from PT_LOAD header
6141 p_paddr in _bfd_elf_make_section_from_shdr.
6142 If this header has a p_paddr that disagrees
6143 with the section lma, flag the p_paddr as
6144 invalid. */
6145 if ((section->flags & SEC_LOAD) != 0)
6146 seg_off = this_hdr->sh_offset - segment->p_offset;
6147 else
6148 seg_off = this_hdr->sh_addr - segment->p_vaddr;
6149 if (section->lma - segment->p_paddr != seg_off)
6150 map->p_paddr_valid = FALSE;
6151 }
53020534
L		 6152 if (isec == section_count)
6153 break;
6154 }
84d1d650
L		 6155 }
6156 }
6157
a76e6f2f
AM		 6158 if (map->includes_filehdr && lowest_section != NULL)
6159 /* We need to keep the space used by the headers fixed. */
6160 map->header_size = lowest_section->vma - segment->p_vaddr;
d324f6d6 6161
a76e6f2f
AM		 6162 if (!map->includes_phdrs
6163 && !map->includes_filehdr
6164 && map->p_paddr_valid)
6165 /* There is some other padding before the first section. */
6166 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
6167 - segment->p_paddr);
6168
84d1d650
L		 6169 map->count = section_count;
6170 *pointer_to_map = map;
6171 pointer_to_map = &map->next;
6172 }
6173
6174 elf_tdata (obfd)->segment_map = map_first;
6175 return TRUE;
6176}
6177
6178/* Copy private BFD data. This copies or rewrites ELF program header
6179 information. */
6180
6181static bfd_boolean
6182copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6183{
84d1d650
L		 6184 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6185 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6186 return TRUE;
6187
6188 if (elf_tdata (ibfd)->phdr == NULL)
6189 return TRUE;
6190
6191 if (ibfd->xvec == obfd->xvec)
6192 {
cb3ff1e5
NC		 6193 /* Check to see if any sections in the input BFD
6194 covered by ELF program header have changed. */
d55ce4e2 6195 Elf_Internal_Phdr *segment;
84d1d650
L		 6196 asection *section, *osec;
6197 unsigned int i, num_segments;
6198 Elf_Internal_Shdr *this_hdr;
147d51c2
L		 6199 const struct elf_backend_data *bed;
6200
6201 bed = get_elf_backend_data (ibfd);
6202
6203 /* Regenerate the segment map if p_paddr is set to 0. */
6204 if (bed->want_p_paddr_set_to_zero)
6205 goto rewrite;
84d1d650
L		 6206
6207 /* Initialize the segment mark field. */
6208 for (section = obfd->sections; section != NULL;
6209 section = section->next)
6210 section->segment_mark = FALSE;
6211
6212 num_segments = elf_elfheader (ibfd)->e_phnum;
6213 for (i = 0, segment = elf_tdata (ibfd)->phdr;
6214 i < num_segments;
6215 i++, segment++)
6216 {
5f6999aa
NC		 6217 /* PR binutils/3535. The Solaris linker always sets the p_paddr
6218 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
6219 which severly confuses things, so always regenerate the segment
6220 map in this case. */
6221 if (segment->p_paddr == 0
6222 && segment->p_memsz == 0
6223 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
cb3ff1e5 6224 goto rewrite;
5f6999aa 6225
84d1d650
L		 6226 for (section = ibfd->sections;
6227 section != NULL; section = section->next)
6228 {
6229 /* We mark the output section so that we know it comes
6230 from the input BFD. */
6231 osec = section->output_section;
6232 if (osec)
6233 osec->segment_mark = TRUE;
6234
6235 /* Check if this section is covered by the segment. */
6236 this_hdr = &(elf_section_data(section)->this_hdr);
f4638467 6237 if (ELF_SECTION_IN_SEGMENT (this_hdr, segment))
84d1d650
L		 6238 {
6239 /* FIXME: Check if its output section is changed or
6240 removed. What else do we need to check? */
6241 if (osec == NULL
6242 || section->flags != osec->flags
6243 || section->lma != osec->lma
6244 || section->vma != osec->vma
6245 || section->size != osec->size
6246 || section->rawsize != osec->rawsize
6247 || section->alignment_power != osec->alignment_power)
6248 goto rewrite;
6249 }
6250 }
6251 }
6252
cb3ff1e5 6253 /* Check to see if any output section do not come from the
84d1d650
L		 6254 input BFD. */
6255 for (section = obfd->sections; section != NULL;
6256 section = section->next)
6257 {
6258 if (section->segment_mark == FALSE)
6259 goto rewrite;
6260 else
6261 section->segment_mark = FALSE;
6262 }
6263
6264 return copy_elf_program_header (ibfd, obfd);
6265 }
6266
6267rewrite:
6268 return rewrite_elf_program_header (ibfd, obfd);
6269}
6270
ccd2ec6a
L		 6271/* Initialize private output section information from input section. */
6272
6273bfd_boolean
6274_bfd_elf_init_private_section_data (bfd *ibfd,
6275 asection *isec,
6276 bfd *obfd,
6277 asection *osec,
6278 struct bfd_link_info *link_info)
6279
6280{
6281 Elf_Internal_Shdr *ihdr, *ohdr;
dfa7b0b8 6282 bfd_boolean final_link = link_info != NULL && !link_info->relocatable;
ccd2ec6a
L		 6283
6284 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6285 || obfd->xvec->flavour != bfd_target_elf_flavour)
6286 return TRUE;
6287
ba85c43e
NC		 6288 BFD_ASSERT (elf_section_data (osec) != NULL);
6289
dfa7b0b8
AM		 6290 /* For objcopy and relocatable link, don't copy the output ELF
6291 section type from input if the output BFD section flags have been
6292 set to something different. For a final link allow some flags
6293 that the linker clears to differ. */
42bb2e33 6294 if (elf_section_type (osec) == SHT_NULL
dfa7b0b8
AM		 6295 && (osec->flags == isec->flags
6296 || (final_link
6297 && ((osec->flags ^ isec->flags)
0814be7d 6298 & ~(SEC_LINK_ONCE | SEC_LINK_DUPLICATES | SEC_RELOC)) == 0)))
42bb2e33 6299 elf_section_type (osec) = elf_section_type (isec);
d270463e
L		 6300
6301 /* FIXME: Is this correct for all OS/PROC specific flags? */
6302 elf_section_flags (osec) |= (elf_section_flags (isec)
6303 & (SHF_MASKOS | SHF_MASKPROC));
ccd2ec6a
L		 6304
6305 /* Set things up for objcopy and relocatable link. The output
6306 SHT_GROUP section will have its elf_next_in_group pointing back
6307 to the input group members. Ignore linker created group section.
6308 See elfNN_ia64_object_p in elfxx-ia64.c. */
dfa7b0b8 6309 if (!final_link)
ccd2ec6a
L		 6310 {
6311 if (elf_sec_group (isec) == NULL
6312 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6313 {
6314 if (elf_section_flags (isec) & SHF_GROUP)
6315 elf_section_flags (osec) |= SHF_GROUP;
6316 elf_next_in_group (osec) = elf_next_in_group (isec);
9659de1c 6317 elf_section_data (osec)->group = elf_section_data (isec)->group;
ccd2ec6a
L		 6318 }
6319 }
6320
6321 ihdr = &elf_section_data (isec)->this_hdr;
6322
6323 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6324 don't use the output section of the linked-to section since it
6325 may be NULL at this point. */
6326 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6327 {
6328 ohdr = &elf_section_data (osec)->this_hdr;
6329 ohdr->sh_flags |= SHF_LINK_ORDER;
6330 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6331 }
6332
6333 osec->use_rela_p = isec->use_rela_p;
6334
6335 return TRUE;
6336}
6337
252b5132
RH		 6338/* Copy private section information. This copies over the entsize
6339 field, and sometimes the info field. */
6340
b34976b6 6341bfd_boolean
217aa764
AM		 6342_bfd_elf_copy_private_section_data (bfd *ibfd,
6343 asection *isec,
6344 bfd *obfd,
6345 asection *osec)
252b5132
RH		 6346{
6347 Elf_Internal_Shdr *ihdr, *ohdr;
6348
6349 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6350 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 6351 return TRUE;
252b5132 6352
252b5132
RH		 6353 ihdr = &elf_section_data (isec)->this_hdr;
6354 ohdr = &elf_section_data (osec)->this_hdr;
6355
6356 ohdr->sh_entsize = ihdr->sh_entsize;
6357
6358 if (ihdr->sh_type == SHT_SYMTAB
6359 || ihdr->sh_type == SHT_DYNSYM
6360 || ihdr->sh_type == SHT_GNU_verneed
6361 || ihdr->sh_type == SHT_GNU_verdef)
6362 ohdr->sh_info = ihdr->sh_info;
6363
ccd2ec6a
L		 6364 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6365 NULL);
252b5132
RH		 6366}
6367
d0bf826b
AM		 6368/* Look at all the SHT_GROUP sections in IBFD, making any adjustments
6369 necessary if we are removing either the SHT_GROUP section or any of
6370 the group member sections. DISCARDED is the value that a section's
6371 output_section has if the section will be discarded, NULL when this
6372 function is called from objcopy, bfd_abs_section_ptr when called
6373 from the linker. */
80fccad2
BW		 6374
6375bfd_boolean
d0bf826b 6376_bfd_elf_fixup_group_sections (bfd *ibfd, asection *discarded)
80fccad2 6377{
30288845
AM		 6378 asection *isec;
6379
30288845 6380 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
415f38a6 6381 if (elf_section_type (isec) == SHT_GROUP)
30288845
AM		 6382 {
6383 asection *first = elf_next_in_group (isec);
6384 asection *s = first;
d0bf826b
AM		 6385 bfd_size_type removed = 0;
6386
30288845
AM		 6387 while (s != NULL)
6388 {
415f38a6
AM		 6389 /* If this member section is being output but the
6390 SHT_GROUP section is not, then clear the group info
6391 set up by _bfd_elf_copy_private_section_data. */
d0bf826b
AM		 6392 if (s->output_section != discarded
6393 && isec->output_section == discarded)
30288845
AM		 6394 {
6395 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6396 elf_group_name (s->output_section) = NULL;
6397 }
415f38a6
AM		 6398 /* Conversely, if the member section is not being output
6399 but the SHT_GROUP section is, then adjust its size. */
d0bf826b
AM		 6400 else if (s->output_section == discarded
6401 && isec->output_section != discarded)
6402 removed += 4;
30288845
AM		 6403 s = elf_next_in_group (s);
6404 if (s == first)
6405 break;
6406 }
d0bf826b
AM		 6407 if (removed != 0)
6408 {
6409 if (discarded != NULL)
6410 {
6411 /* If we've been called for ld -r, then we need to
6412 adjust the input section size. This function may
6413 be called multiple times, so save the original
6414 size. */
6415 if (isec->rawsize == 0)
6416 isec->rawsize = isec->size;
6417 isec->size = isec->rawsize - removed;
6418 }
6419 else
6420 {
6421 /* Adjust the output section size when called from
6422 objcopy. */
6423 isec->output_section->size -= removed;
6424 }
6425 }
30288845
AM		 6426 }
6427
80fccad2
BW		 6428 return TRUE;
6429}
6430
d0bf826b
AM		 6431/* Copy private header information. */
6432
6433bfd_boolean
6434_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6435{
6436 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6437 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6438 return TRUE;
6439
6440 /* Copy over private BFD data if it has not already been copied.
6441 This must be done here, rather than in the copy_private_bfd_data
6442 entry point, because the latter is called after the section
6443 contents have been set, which means that the program headers have
6444 already been worked out. */
6445 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6446 {
6447 if (! copy_private_bfd_data (ibfd, obfd))
6448 return FALSE;
6449 }
6450
6451 return _bfd_elf_fixup_group_sections (ibfd, NULL);
6452}
6453
252b5132
RH		 6454/* Copy private symbol information. If this symbol is in a section
6455 which we did not map into a BFD section, try to map the section
6456 index correctly. We use special macro definitions for the mapped
6457 section indices; these definitions are interpreted by the
6458 swap_out_syms function. */
6459
9ad5cbcf
AM		 6460#define MAP_ONESYMTAB (SHN_HIOS + 1)
6461#define MAP_DYNSYMTAB (SHN_HIOS + 2)
6462#define MAP_STRTAB (SHN_HIOS + 3)
6463#define MAP_SHSTRTAB (SHN_HIOS + 4)
6464#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 6465
b34976b6 6466bfd_boolean
217aa764
AM		 6467_bfd_elf_copy_private_symbol_data (bfd *ibfd,
6468 asymbol *isymarg,
6469 bfd *obfd,
6470 asymbol *osymarg)
252b5132
RH		 6471{
6472 elf_symbol_type *isym, *osym;
6473
6474 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6475 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 6476 return TRUE;
252b5132
RH		 6477
6478 isym = elf_symbol_from (ibfd, isymarg);
6479 osym = elf_symbol_from (obfd, osymarg);
6480
6481 if (isym != NULL
8424d8f5 6482 && isym->internal_elf_sym.st_shndx != 0
252b5132
RH		 6483 && osym != NULL
6484 && bfd_is_abs_section (isym->symbol.section))
6485 {
6486 unsigned int shndx;
6487
6488 shndx = isym->internal_elf_sym.st_shndx;
6489 if (shndx == elf_onesymtab (ibfd))
6490 shndx = MAP_ONESYMTAB;
6491 else if (shndx == elf_dynsymtab (ibfd))
6492 shndx = MAP_DYNSYMTAB;
6493 else if (shndx == elf_tdata (ibfd)->strtab_section)
6494 shndx = MAP_STRTAB;
6495 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6496 shndx = MAP_SHSTRTAB;
9ad5cbcf
AM		 6497 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6498 shndx = MAP_SYM_SHNDX;
252b5132
RH		 6499 osym->internal_elf_sym.st_shndx = shndx;
6500 }
6501
b34976b6 6502 return TRUE;
252b5132
RH		 6503}
6504
6505/* Swap out the symbols. */
6506
b34976b6 6507static bfd_boolean
217aa764
AM		 6508swap_out_syms (bfd *abfd,
6509 struct bfd_strtab_hash **sttp,
6510 int relocatable_p)
252b5132 6511{
9c5bfbb7 6512 const struct elf_backend_data *bed;
079e9a2f
AM		 6513 int symcount;
6514 asymbol **syms;
6515 struct bfd_strtab_hash *stt;
6516 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 6517 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f 6518 Elf_Internal_Shdr *symstrtab_hdr;
f075ee0c
AM		 6519 bfd_byte *outbound_syms;
6520 bfd_byte *outbound_shndx;
079e9a2f
AM		 6521 int idx;
6522 bfd_size_type amt;
174fd7f9 6523 bfd_boolean name_local_sections;
252b5132
RH		 6524
6525 if (!elf_map_symbols (abfd))
b34976b6 6526 return FALSE;
252b5132 6527
c044fabd 6528 /* Dump out the symtabs. */
079e9a2f
AM		 6529 stt = _bfd_elf_stringtab_init ();
6530 if (stt == NULL)
b34976b6 6531 return FALSE;
252b5132 6532
079e9a2f
AM		 6533 bed = get_elf_backend_data (abfd);
6534 symcount = bfd_get_symcount (abfd);
6535 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6536 symtab_hdr->sh_type = SHT_SYMTAB;
6537 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6538 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6539 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
72de5009 6540 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
079e9a2f
AM		 6541
6542 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6543 symstrtab_hdr->sh_type = SHT_STRTAB;
6544
a50b1753
NC		 6545 outbound_syms = (bfd_byte *) bfd_alloc2 (abfd, 1 + symcount,
6546 bed->s->sizeof_sym);
079e9a2f 6547 if (outbound_syms == NULL)
5ed6aba4
NC		 6548 {
6549 _bfd_stringtab_free (stt);
6550 return FALSE;
6551 }
217aa764 6552 symtab_hdr->contents = outbound_syms;
252b5132 6553
9ad5cbcf
AM		 6554 outbound_shndx = NULL;
6555 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6556 if (symtab_shndx_hdr->sh_name != 0)
6557 {
6558 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
a50b1753
NC		 6559 outbound_shndx = (bfd_byte *)
6560 bfd_zalloc2 (abfd, 1 + symcount, sizeof (Elf_External_Sym_Shndx));
9ad5cbcf 6561 if (outbound_shndx == NULL)
5ed6aba4
NC		 6562 {
6563 _bfd_stringtab_free (stt);
6564 return FALSE;
6565 }
6566
9ad5cbcf
AM		 6567 symtab_shndx_hdr->contents = outbound_shndx;
6568 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6569 symtab_shndx_hdr->sh_size = amt;
6570 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6571 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6572 }
6573
589e6347 6574 /* Now generate the data (for "contents"). */
079e9a2f
AM		 6575 {
6576 /* Fill in zeroth symbol and swap it out. */
6577 Elf_Internal_Sym sym;
6578 sym.st_name = 0;
6579 sym.st_value = 0;
6580 sym.st_size = 0;
6581 sym.st_info = 0;
6582 sym.st_other = 0;
6583 sym.st_shndx = SHN_UNDEF;
35fc36a8 6584 sym.st_target_internal = 0;
9ad5cbcf 6585 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6586 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 6587 if (outbound_shndx != NULL)
6588 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6589 }
252b5132 6590
174fd7f9
RS		 6591 name_local_sections
6592 = (bed->elf_backend_name_local_section_symbols
6593 && bed->elf_backend_name_local_section_symbols (abfd));
6594
079e9a2f
AM		 6595 syms = bfd_get_outsymbols (abfd);
6596 for (idx = 0; idx < symcount; idx++)
252b5132 6597 {
252b5132 6598 Elf_Internal_Sym sym;
079e9a2f
AM		 6599 bfd_vma value = syms[idx]->value;
6600 elf_symbol_type *type_ptr;
6601 flagword flags = syms[idx]->flags;
6602 int type;
252b5132 6603
174fd7f9
RS		 6604 if (!name_local_sections
6605 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM		 6606 {
6607 /* Local section symbols have no name. */
6608 sym.st_name = 0;
6609 }
6610 else
6611 {
6612 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6613 syms[idx]->name,
b34976b6 6614 TRUE, FALSE);
079e9a2f 6615 if (sym.st_name == (unsigned long) -1)
5ed6aba4
NC		 6616 {
6617 _bfd_stringtab_free (stt);
6618 return FALSE;
6619 }
079e9a2f 6620 }
252b5132 6621
079e9a2f 6622 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 6623
079e9a2f
AM		 6624 if ((flags & BSF_SECTION_SYM) == 0
6625 && bfd_is_com_section (syms[idx]->section))
6626 {
6627 /* ELF common symbols put the alignment into the `value' field,
6628 and the size into the `size' field. This is backwards from
6629 how BFD handles it, so reverse it here. */
6630 sym.st_size = value;
6631 if (type_ptr == NULL
6632 || type_ptr->internal_elf_sym.st_value == 0)
6633 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6634 else
6635 sym.st_value = type_ptr->internal_elf_sym.st_value;
6636 sym.st_shndx = _bfd_elf_section_from_bfd_section
6637 (abfd, syms[idx]->section);
6638 }
6639 else
6640 {
6641 asection *sec = syms[idx]->section;
cb33740c 6642 unsigned int shndx;
252b5132 6643
079e9a2f
AM		 6644 if (sec->output_section)
6645 {
6646 value += sec->output_offset;
6647 sec = sec->output_section;
6648 }
589e6347 6649
079e9a2f
AM		 6650 /* Don't add in the section vma for relocatable output. */
6651 if (! relocatable_p)
6652 value += sec->vma;
6653 sym.st_value = value;
6654 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6655
6656 if (bfd_is_abs_section (sec)
6657 && type_ptr != NULL
6658 && type_ptr->internal_elf_sym.st_shndx != 0)
6659 {
6660 /* This symbol is in a real ELF section which we did
6661 not create as a BFD section. Undo the mapping done
6662 by copy_private_symbol_data. */
6663 shndx = type_ptr->internal_elf_sym.st_shndx;
6664 switch (shndx)
6665 {
6666 case MAP_ONESYMTAB:
6667 shndx = elf_onesymtab (abfd);
6668 break;
6669 case MAP_DYNSYMTAB:
6670 shndx = elf_dynsymtab (abfd);
6671 break;
6672 case MAP_STRTAB:
6673 shndx = elf_tdata (abfd)->strtab_section;
6674 break;
6675 case MAP_SHSTRTAB:
6676 shndx = elf_tdata (abfd)->shstrtab_section;
6677 break;
9ad5cbcf
AM		 6678 case MAP_SYM_SHNDX:
6679 shndx = elf_tdata (abfd)->symtab_shndx_section;
6680 break;
079e9a2f
AM		 6681 default:
6682 break;
6683 }
6684 }
6685 else
6686 {
6687 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 6688
cb33740c 6689 if (shndx == SHN_BAD)
079e9a2f
AM		 6690 {
6691 asection *sec2;
6692
6693 /* Writing this would be a hell of a lot easier if
6694 we had some decent documentation on bfd, and
6695 knew what to expect of the library, and what to
6696 demand of applications. For example, it
6697 appears that `objcopy' might not set the
6698 section of a symbol to be a section that is
6699 actually in the output file. */
6700 sec2 = bfd_get_section_by_name (abfd, sec->name);
589e6347
NC		 6701 if (sec2 == NULL)
6702 {
6703 _bfd_error_handler (_("\
6704Unable to find equivalent output section for symbol '%s' from section '%s'"),
6705 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6706 sec->name);
811072d8 6707 bfd_set_error (bfd_error_invalid_operation);
5ed6aba4 6708 _bfd_stringtab_free (stt);
589e6347
NC		 6709 return FALSE;
6710 }
811072d8 6711
079e9a2f 6712 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
cb33740c 6713 BFD_ASSERT (shndx != SHN_BAD);
079e9a2f
AM		 6714 }
6715 }
252b5132 6716
079e9a2f
AM		 6717 sym.st_shndx = shndx;
6718 }
252b5132 6719
13ae64f3
JJ		 6720 if ((flags & BSF_THREAD_LOCAL) != 0)
6721 type = STT_TLS;
d8045f23
NC		 6722 else if ((flags & BSF_GNU_INDIRECT_FUNCTION) != 0)
6723 type = STT_GNU_IFUNC;
13ae64f3 6724 else if ((flags & BSF_FUNCTION) != 0)
079e9a2f
AM		 6725 type = STT_FUNC;
6726 else if ((flags & BSF_OBJECT) != 0)
6727 type = STT_OBJECT;
d9352518
DB		 6728 else if ((flags & BSF_RELC) != 0)
6729 type = STT_RELC;
6730 else if ((flags & BSF_SRELC) != 0)
6731 type = STT_SRELC;
079e9a2f
AM		 6732 else
6733 type = STT_NOTYPE;
252b5132 6734
13ae64f3
JJ		 6735 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6736 type = STT_TLS;
6737
589e6347 6738 /* Processor-specific types. */
079e9a2f
AM		 6739 if (type_ptr != NULL
6740 && bed->elf_backend_get_symbol_type)
6741 type = ((*bed->elf_backend_get_symbol_type)
6742 (&type_ptr->internal_elf_sym, type));
252b5132 6743
079e9a2f
AM		 6744 if (flags & BSF_SECTION_SYM)
6745 {
6746 if (flags & BSF_GLOBAL)
6747 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6748 else
6749 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6750 }
6751 else if (bfd_is_com_section (syms[idx]->section))
0a40daed 6752 {
504b7d20 6753#ifdef USE_STT_COMMON
0a40daed
MK		 6754 if (type == STT_OBJECT)
6755 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_COMMON);
6756 else
504b7d20 6757#endif
c91e322a 6758 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
0a40daed 6759 }
079e9a2f
AM		 6760 else if (bfd_is_und_section (syms[idx]->section))
6761 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6762 ? STB_WEAK
6763 : STB_GLOBAL),
6764 type);
6765 else if (flags & BSF_FILE)
6766 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6767 else
6768 {
6769 int bind = STB_LOCAL;
252b5132 6770
079e9a2f
AM		 6771 if (flags & BSF_LOCAL)
6772 bind = STB_LOCAL;
3e7a7d11
NC		 6773 else if (flags & BSF_GNU_UNIQUE)
6774 bind = STB_GNU_UNIQUE;
079e9a2f
AM		 6775 else if (flags & BSF_WEAK)
6776 bind = STB_WEAK;
6777 else if (flags & BSF_GLOBAL)
6778 bind = STB_GLOBAL;
252b5132 6779
079e9a2f
AM		 6780 sym.st_info = ELF_ST_INFO (bind, type);
6781 }
252b5132 6782
079e9a2f 6783 if (type_ptr != NULL)
35fc36a8
RS		 6784 {
6785 sym.st_other = type_ptr->internal_elf_sym.st_other;
6786 sym.st_target_internal
6787 = type_ptr->internal_elf_sym.st_target_internal;
6788 }
079e9a2f 6789 else
35fc36a8
RS		 6790 {
6791 sym.st_other = 0;
6792 sym.st_target_internal = 0;
6793 }
252b5132 6794
9ad5cbcf 6795 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6796 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 6797 if (outbound_shndx != NULL)
6798 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6799 }
252b5132 6800
079e9a2f
AM		 6801 *sttp = stt;
6802 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6803 symstrtab_hdr->sh_type = SHT_STRTAB;
252b5132 6804
079e9a2f
AM		 6805 symstrtab_hdr->sh_flags = 0;
6806 symstrtab_hdr->sh_addr = 0;
6807 symstrtab_hdr->sh_entsize = 0;
6808 symstrtab_hdr->sh_link = 0;
6809 symstrtab_hdr->sh_info = 0;
6810 symstrtab_hdr->sh_addralign = 1;
252b5132 6811
b34976b6 6812 return TRUE;
252b5132
RH		 6813}
6814
6815/* Return the number of bytes required to hold the symtab vector.
6816
6817 Note that we base it on the count plus 1, since we will null terminate
6818 the vector allocated based on this size. However, the ELF symbol table
6819 always has a dummy entry as symbol #0, so it ends up even. */
6820
6821long
217aa764 6822_bfd_elf_get_symtab_upper_bound (bfd *abfd)
252b5132
RH		 6823{
6824 long symcount;
6825 long symtab_size;
6826 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6827
6828 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM		 6829 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6830 if (symcount > 0)
6831 symtab_size -= sizeof (asymbol *);
252b5132
RH		 6832
6833 return symtab_size;
6834}
6835
6836long
217aa764 6837_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
252b5132
RH		 6838{
6839 long symcount;
6840 long symtab_size;
6841 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6842
6843 if (elf_dynsymtab (abfd) == 0)
6844 {
6845 bfd_set_error (bfd_error_invalid_operation);
6846 return -1;
6847 }
6848
6849 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM		 6850 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6851 if (symcount > 0)
6852 symtab_size -= sizeof (asymbol *);
252b5132
RH		 6853
6854 return symtab_size;
6855}
6856
6857long
217aa764
AM		 6858_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6859 sec_ptr asect)
252b5132
RH		 6860{
6861 return (asect->reloc_count + 1) * sizeof (arelent *);
6862}
6863
6864/* Canonicalize the relocs. */
6865
6866long
217aa764
AM		 6867_bfd_elf_canonicalize_reloc (bfd *abfd,
6868 sec_ptr section,
6869 arelent **relptr,
6870 asymbol **symbols)
252b5132
RH		 6871{
6872 arelent *tblptr;
6873 unsigned int i;
9c5bfbb7 6874 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 6875
b34976b6 6876 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
252b5132
RH		 6877 return -1;
6878
6879 tblptr = section->relocation;
6880 for (i = 0; i < section->reloc_count; i++)
6881 *relptr++ = tblptr++;
6882
6883 *relptr = NULL;
6884
6885 return section->reloc_count;
6886}
6887
6888long
6cee3f79 6889_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
252b5132 6890{
9c5bfbb7 6891 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 6892 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
252b5132
RH		 6893
6894 if (symcount >= 0)
6895 bfd_get_symcount (abfd) = symcount;
6896 return symcount;
6897}
6898
6899long
217aa764
AM		 6900_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6901 asymbol **allocation)
252b5132 6902{
9c5bfbb7 6903 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 6904 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
1f70368c
DJ		 6905
6906 if (symcount >= 0)
6907 bfd_get_dynamic_symcount (abfd) = symcount;
6908 return symcount;
252b5132
RH		 6909}
6910
8615f3f2
AM		 6911/* Return the size required for the dynamic reloc entries. Any loadable
6912 section that was actually installed in the BFD, and has type SHT_REL
6913 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6914 dynamic reloc section. */
252b5132
RH		 6915
6916long
217aa764 6917_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
252b5132
RH		 6918{
6919 long ret;
6920 asection *s;
6921
6922 if (elf_dynsymtab (abfd) == 0)
6923 {
6924 bfd_set_error (bfd_error_invalid_operation);
6925 return -1;
6926 }
6927
6928 ret = sizeof (arelent *);
6929 for (s = abfd->sections; s != NULL; s = s->next)
266b05cf 6930 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH		 6931 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6932 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
eea6121a 6933 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
252b5132
RH		 6934 * sizeof (arelent *));
6935
6936 return ret;
6937}
6938
8615f3f2
AM		 6939/* Canonicalize the dynamic relocation entries. Note that we return the
6940 dynamic relocations as a single block, although they are actually
6941 associated with particular sections; the interface, which was
6942 designed for SunOS style shared libraries, expects that there is only
6943 one set of dynamic relocs. Any loadable section that was actually
6944 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6945 dynamic symbol table, is considered to be a dynamic reloc section. */
252b5132
RH		 6946
6947long
217aa764
AM		 6948_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6949 arelent **storage,
6950 asymbol **syms)
252b5132 6951{
217aa764 6952 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
252b5132
RH		 6953 asection *s;
6954 long ret;
6955
6956 if (elf_dynsymtab (abfd) == 0)
6957 {
6958 bfd_set_error (bfd_error_invalid_operation);
6959 return -1;
6960 }
6961
6962 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6963 ret = 0;
6964 for (s = abfd->sections; s != NULL; s = s->next)
6965 {
266b05cf 6966 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH		 6967 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6968 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6969 {
6970 arelent *p;
6971 long count, i;
6972
b34976b6 6973 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
252b5132 6974 return -1;
eea6121a 6975 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
252b5132
RH		 6976 p = s->relocation;
6977 for (i = 0; i < count; i++)
6978 *storage++ = p++;
6979 ret += count;
6980 }
6981 }
6982
6983 *storage = NULL;
6984
6985 return ret;
6986}
6987\f
6988/* Read in the version information. */
6989
b34976b6 6990bfd_boolean
fc0e6df6 6991_bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
252b5132
RH		 6992{
6993 bfd_byte *contents = NULL;
fc0e6df6
PB		 6994 unsigned int freeidx = 0;
6995
6996 if (elf_dynverref (abfd) != 0)
6997 {
6998 Elf_Internal_Shdr *hdr;
6999 Elf_External_Verneed *everneed;
7000 Elf_Internal_Verneed *iverneed;
7001 unsigned int i;
d0fb9a8d 7002 bfd_byte *contents_end;
fc0e6df6
PB		 7003
7004 hdr = &elf_tdata (abfd)->dynverref_hdr;
7005
a50b1753
NC		 7006 elf_tdata (abfd)->verref = (Elf_Internal_Verneed *)
7007 bfd_zalloc2 (abfd, hdr->sh_info, sizeof (Elf_Internal_Verneed));
fc0e6df6
PB		 7008 if (elf_tdata (abfd)->verref == NULL)
7009 goto error_return;
7010
7011 elf_tdata (abfd)->cverrefs = hdr->sh_info;
7012
a50b1753 7013 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
fc0e6df6 7014 if (contents == NULL)
d0fb9a8d
JJ		 7015 {
7016error_return_verref:
7017 elf_tdata (abfd)->verref = NULL;
7018 elf_tdata (abfd)->cverrefs = 0;
7019 goto error_return;
7020 }
fc0e6df6
PB		 7021 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
7022 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
d0fb9a8d 7023 goto error_return_verref;
fc0e6df6 7024
d0fb9a8d
JJ		 7025 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
7026 goto error_return_verref;
7027
7028 BFD_ASSERT (sizeof (Elf_External_Verneed)
7029 == sizeof (Elf_External_Vernaux));
7030 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
fc0e6df6
PB		 7031 everneed = (Elf_External_Verneed *) contents;
7032 iverneed = elf_tdata (abfd)->verref;
7033 for (i = 0; i < hdr->sh_info; i++, iverneed++)
7034 {
7035 Elf_External_Vernaux *evernaux;
7036 Elf_Internal_Vernaux *ivernaux;
7037 unsigned int j;
7038
7039 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
7040
7041 iverneed->vn_bfd = abfd;
7042
7043 iverneed->vn_filename =
7044 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7045 iverneed->vn_file);
7046 if (iverneed->vn_filename == NULL)
d0fb9a8d 7047 goto error_return_verref;
fc0e6df6 7048
d0fb9a8d
JJ		 7049 if (iverneed->vn_cnt == 0)
7050 iverneed->vn_auxptr = NULL;
7051 else
7052 {
a50b1753
NC		 7053 iverneed->vn_auxptr = (struct elf_internal_vernaux *)
7054 bfd_alloc2 (abfd, iverneed->vn_cnt,
7055 sizeof (Elf_Internal_Vernaux));
d0fb9a8d
JJ		 7056 if (iverneed->vn_auxptr == NULL)
7057 goto error_return_verref;
7058 }
7059
7060 if (iverneed->vn_aux
7061 > (size_t) (contents_end - (bfd_byte *) everneed))
7062 goto error_return_verref;
fc0e6df6
PB		 7063
7064 evernaux = ((Elf_External_Vernaux *)
7065 ((bfd_byte *) everneed + iverneed->vn_aux));
7066 ivernaux = iverneed->vn_auxptr;
7067 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
7068 {
7069 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
7070
7071 ivernaux->vna_nodename =
7072 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7073 ivernaux->vna_name);
7074 if (ivernaux->vna_nodename == NULL)
d0fb9a8d 7075 goto error_return_verref;
fc0e6df6
PB		 7076
7077 if (j + 1 < iverneed->vn_cnt)
7078 ivernaux->vna_nextptr = ivernaux + 1;
7079 else
7080 ivernaux->vna_nextptr = NULL;
7081
d0fb9a8d
JJ		 7082 if (ivernaux->vna_next
7083 > (size_t) (contents_end - (bfd_byte *) evernaux))
7084 goto error_return_verref;
7085
fc0e6df6
PB		 7086 evernaux = ((Elf_External_Vernaux *)
7087 ((bfd_byte *) evernaux + ivernaux->vna_next));
7088
7089 if (ivernaux->vna_other > freeidx)
7090 freeidx = ivernaux->vna_other;
7091 }
7092
7093 if (i + 1 < hdr->sh_info)
7094 iverneed->vn_nextref = iverneed + 1;
7095 else
7096 iverneed->vn_nextref = NULL;
7097
d0fb9a8d
JJ		 7098 if (iverneed->vn_next
7099 > (size_t) (contents_end - (bfd_byte *) everneed))
7100 goto error_return_verref;
7101
fc0e6df6
PB		 7102 everneed = ((Elf_External_Verneed *)
7103 ((bfd_byte *) everneed + iverneed->vn_next));
7104 }
7105
7106 free (contents);
7107 contents = NULL;
7108 }
252b5132
RH		 7109
7110 if (elf_dynverdef (abfd) != 0)
7111 {
7112 Elf_Internal_Shdr *hdr;
7113 Elf_External_Verdef *everdef;
7114 Elf_Internal_Verdef *iverdef;
f631889e
UD		 7115 Elf_Internal_Verdef *iverdefarr;
7116 Elf_Internal_Verdef iverdefmem;
252b5132 7117 unsigned int i;
062e2358 7118 unsigned int maxidx;
d0fb9a8d 7119 bfd_byte *contents_end_def, *contents_end_aux;
252b5132
RH		 7120
7121 hdr = &elf_tdata (abfd)->dynverdef_hdr;
7122
a50b1753 7123 contents = (bfd_byte *) bfd_malloc (hdr->sh_size);
252b5132
RH		 7124 if (contents == NULL)
7125 goto error_return;
7126 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 7127 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
252b5132
RH		 7128 goto error_return;
7129
d0fb9a8d
JJ		 7130 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
7131 goto error_return;
7132
7133 BFD_ASSERT (sizeof (Elf_External_Verdef)
7134 >= sizeof (Elf_External_Verdaux));
7135 contents_end_def = contents + hdr->sh_size
7136 - sizeof (Elf_External_Verdef);
7137 contents_end_aux = contents + hdr->sh_size
7138 - sizeof (Elf_External_Verdaux);
7139
f631889e
UD		 7140 /* We know the number of entries in the section but not the maximum
7141 index. Therefore we have to run through all entries and find
7142 the maximum. */
252b5132 7143 everdef = (Elf_External_Verdef *) contents;
f631889e
UD		 7144 maxidx = 0;
7145 for (i = 0; i < hdr->sh_info; ++i)
7146 {
7147 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7148
062e2358
AM		 7149 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
7150 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
f631889e 7151
d0fb9a8d
JJ		 7152 if (iverdefmem.vd_next
7153 > (size_t) (contents_end_def - (bfd_byte *) everdef))
7154 goto error_return;
7155
f631889e
UD		 7156 everdef = ((Elf_External_Verdef *)
7157 ((bfd_byte *) everdef + iverdefmem.vd_next));
7158 }
7159
fc0e6df6
PB		 7160 if (default_imported_symver)
7161 {
7162 if (freeidx > maxidx)
7163 maxidx = ++freeidx;
7164 else
7165 freeidx = ++maxidx;
7166 }
a50b1753
NC		 7167 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7168 bfd_zalloc2 (abfd, maxidx, sizeof (Elf_Internal_Verdef));
f631889e
UD		 7169 if (elf_tdata (abfd)->verdef == NULL)
7170 goto error_return;
7171
7172 elf_tdata (abfd)->cverdefs = maxidx;
7173
7174 everdef = (Elf_External_Verdef *) contents;
7175 iverdefarr = elf_tdata (abfd)->verdef;
7176 for (i = 0; i < hdr->sh_info; i++)
252b5132
RH		 7177 {
7178 Elf_External_Verdaux *everdaux;
7179 Elf_Internal_Verdaux *iverdaux;
7180 unsigned int j;
7181
f631889e
UD		 7182 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
7183
d0fb9a8d
JJ		 7184 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
7185 {
7186error_return_verdef:
7187 elf_tdata (abfd)->verdef = NULL;
7188 elf_tdata (abfd)->cverdefs = 0;
7189 goto error_return;
7190 }
7191
f631889e
UD		 7192 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
7193 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
252b5132
RH		 7194
7195 iverdef->vd_bfd = abfd;
7196
d0fb9a8d
JJ		 7197 if (iverdef->vd_cnt == 0)
7198 iverdef->vd_auxptr = NULL;
7199 else
7200 {
a50b1753
NC		 7201 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7202 bfd_alloc2 (abfd, iverdef->vd_cnt,
7203 sizeof (Elf_Internal_Verdaux));
d0fb9a8d
JJ		 7204 if (iverdef->vd_auxptr == NULL)
7205 goto error_return_verdef;
7206 }
7207
7208 if (iverdef->vd_aux
7209 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
7210 goto error_return_verdef;
252b5132
RH		 7211
7212 everdaux = ((Elf_External_Verdaux *)
7213 ((bfd_byte *) everdef + iverdef->vd_aux));
7214 iverdaux = iverdef->vd_auxptr;
7215 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
7216 {
7217 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
7218
7219 iverdaux->vda_nodename =
7220 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
7221 iverdaux->vda_name);
7222 if (iverdaux->vda_nodename == NULL)
d0fb9a8d 7223 goto error_return_verdef;
252b5132
RH		 7224
7225 if (j + 1 < iverdef->vd_cnt)
7226 iverdaux->vda_nextptr = iverdaux + 1;
7227 else
7228 iverdaux->vda_nextptr = NULL;
7229
d0fb9a8d
JJ		 7230 if (iverdaux->vda_next
7231 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
7232 goto error_return_verdef;
7233
252b5132
RH		 7234 everdaux = ((Elf_External_Verdaux *)
7235 ((bfd_byte *) everdaux + iverdaux->vda_next));
7236 }
7237
d0fb9a8d
JJ		 7238 if (iverdef->vd_cnt)
7239 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
252b5132 7240
d0fb9a8d 7241 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
252b5132
RH		 7242 iverdef->vd_nextdef = iverdef + 1;
7243 else
7244 iverdef->vd_nextdef = NULL;
7245
7246 everdef = ((Elf_External_Verdef *)
7247 ((bfd_byte *) everdef + iverdef->vd_next));
7248 }
7249
7250 free (contents);
7251 contents = NULL;
7252 }
fc0e6df6 7253 else if (default_imported_symver)
252b5132 7254 {
fc0e6df6
PB		 7255 if (freeidx < 3)
7256 freeidx = 3;
7257 else
7258 freeidx++;
252b5132 7259
a50b1753
NC		 7260 elf_tdata (abfd)->verdef = (Elf_Internal_Verdef *)
7261 bfd_zalloc2 (abfd, freeidx, sizeof (Elf_Internal_Verdef));
fc0e6df6 7262 if (elf_tdata (abfd)->verdef == NULL)
252b5132
RH		 7263 goto error_return;
7264
fc0e6df6
PB		 7265 elf_tdata (abfd)->cverdefs = freeidx;
7266 }
252b5132 7267
fc0e6df6
PB		 7268 /* Create a default version based on the soname. */
7269 if (default_imported_symver)
7270 {
7271 Elf_Internal_Verdef *iverdef;
7272 Elf_Internal_Verdaux *iverdaux;
252b5132 7273
fc0e6df6 7274 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
252b5132 7275
fc0e6df6
PB		 7276 iverdef->vd_version = VER_DEF_CURRENT;
7277 iverdef->vd_flags = 0;
7278 iverdef->vd_ndx = freeidx;
7279 iverdef->vd_cnt = 1;
252b5132 7280
fc0e6df6 7281 iverdef->vd_bfd = abfd;
252b5132 7282
fc0e6df6
PB		 7283 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
7284 if (iverdef->vd_nodename == NULL)
d0fb9a8d 7285 goto error_return_verdef;
fc0e6df6 7286 iverdef->vd_nextdef = NULL;
a50b1753
NC		 7287 iverdef->vd_auxptr = (struct elf_internal_verdaux *)
7288 bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
d0fb9a8d
JJ		 7289 if (iverdef->vd_auxptr == NULL)
7290 goto error_return_verdef;
252b5132 7291
fc0e6df6
PB		 7292 iverdaux = iverdef->vd_auxptr;
7293 iverdaux->vda_nodename = iverdef->vd_nodename;
7294 iverdaux->vda_nextptr = NULL;
252b5132
RH		 7295 }
7296
b34976b6 7297 return TRUE;
252b5132
RH		 7298
7299 error_return:
5ed6aba4 7300 if (contents != NULL)
252b5132 7301 free (contents);
b34976b6 7302 return FALSE;
252b5132
RH		 7303}
7304\f
7305asymbol *
217aa764 7306_bfd_elf_make_empty_symbol (bfd *abfd)
252b5132
RH		 7307{
7308 elf_symbol_type *newsym;
dc810e39 7309 bfd_size_type amt = sizeof (elf_symbol_type);
252b5132 7310
a50b1753 7311 newsym = (elf_symbol_type *) bfd_zalloc (abfd, amt);
252b5132
RH		 7312 if (!newsym)
7313 return NULL;
7314 else
7315 {
7316 newsym->symbol.the_bfd = abfd;
7317 return &newsym->symbol;
7318 }
7319}
7320
7321void
217aa764
AM		 7322_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
7323 asymbol *symbol,
7324 symbol_info *ret)
252b5132
RH		 7325{
7326 bfd_symbol_info (symbol, ret);
7327}
7328
7329/* Return whether a symbol name implies a local symbol. Most targets
7330 use this function for the is_local_label_name entry point, but some
7331 override it. */
7332
b34976b6 7333bfd_boolean
217aa764
AM		 7334_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
7335 const char *name)
252b5132
RH		 7336{
7337 /* Normal local symbols start with ``.L''. */
7338 if (name[0] == '.' && name[1] == 'L')
b34976b6 7339 return TRUE;
252b5132
RH		 7340
7341 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
7342 DWARF debugging symbols starting with ``..''. */
7343 if (name[0] == '.' && name[1] == '.')
b34976b6 7344 return TRUE;
252b5132
RH		 7345
7346 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
7347 emitting DWARF debugging output. I suspect this is actually a
7348 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
7349 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
7350 underscore to be emitted on some ELF targets). For ease of use,
7351 we treat such symbols as local. */
7352 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
b34976b6 7353 return TRUE;
252b5132 7354
b34976b6 7355 return FALSE;
252b5132
RH		 7356}
7357
7358alent *
217aa764
AM		 7359_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
7360 asymbol *symbol ATTRIBUTE_UNUSED)
252b5132
RH		 7361{
7362 abort ();
7363 return NULL;
7364}
7365
b34976b6 7366bfd_boolean
217aa764
AM		 7367_bfd_elf_set_arch_mach (bfd *abfd,
7368 enum bfd_architecture arch,
7369 unsigned long machine)
252b5132
RH		 7370{
7371 /* If this isn't the right architecture for this backend, and this
7372 isn't the generic backend, fail. */
7373 if (arch != get_elf_backend_data (abfd)->arch
7374 && arch != bfd_arch_unknown
7375 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
b34976b6 7376 return FALSE;
252b5132
RH		 7377
7378 return bfd_default_set_arch_mach (abfd, arch, machine);
7379}
7380
d1fad7c6
NC		 7381/* Find the function to a particular section and offset,
7382 for error reporting. */
252b5132 7383
b34976b6 7384static bfd_boolean
b9d678e0 7385elf_find_function (bfd *abfd,
217aa764
AM		 7386 asection *section,
7387 asymbol **symbols,
7388 bfd_vma offset,
7389 const char **filename_ptr,
7390 const char **functionname_ptr)
252b5132 7391{
252b5132 7392 const char *filename;
57426232 7393 asymbol *func, *file;
252b5132
RH		 7394 bfd_vma low_func;
7395 asymbol **p;
57426232
JB		 7396 /* ??? Given multiple file symbols, it is impossible to reliably
7397 choose the right file name for global symbols. File symbols are
7398 local symbols, and thus all file symbols must sort before any
7399 global symbols. The ELF spec may be interpreted to say that a
7400 file symbol must sort before other local symbols, but currently
7401 ld -r doesn't do this. So, for ld -r output, it is possible to
7402 make a better choice of file name for local symbols by ignoring
7403 file symbols appearing after a given local symbol. */
7404 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
b9d678e0 7405 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 7406
a06c7d5a
NC		 7407 if (symbols == NULL)
7408 return FALSE;
7409
252b5132
RH		 7410 filename = NULL;
7411 func = NULL;
57426232 7412 file = NULL;
252b5132 7413 low_func = 0;
57426232 7414 state = nothing_seen;
252b5132
RH		 7415
7416 for (p = symbols; *p != NULL; p++)
7417 {
ff9e0f5b 7418 asymbol *sym = *p;
9f296da3
AM		 7419 asection *code_sec;
7420 bfd_vma code_off;
252b5132 7421
ff9e0f5b 7422 if ((sym->flags & BSF_FILE) != 0)
252b5132 7423 {
ff9e0f5b 7424 file = sym;
57426232
JB		 7425 if (state == symbol_seen)
7426 state = file_after_symbol_seen;
7427 continue;
ff9e0f5b
AM		 7428 }
7429
7430 if (bed->maybe_function_sym (sym, &code_sec, &code_off)
7431 && code_sec == section
7432 && code_off >= low_func
7433 && code_off <= offset)
7434 {
7435 func = sym;
7436 low_func = code_off;
7437 filename = NULL;
7438 if (file != NULL
7439 && ((sym->flags & BSF_LOCAL) != 0
7440 || state != file_after_symbol_seen))
7441 filename = bfd_asymbol_name (file);
252b5132 7442 }
57426232
JB		 7443 if (state == nothing_seen)
7444 state = symbol_seen;
252b5132
RH		 7445 }
7446
7447 if (func == NULL)
b34976b6 7448 return FALSE;
252b5132 7449
d1fad7c6
NC		 7450 if (filename_ptr)
7451 *filename_ptr = filename;
7452 if (functionname_ptr)
7453 *functionname_ptr = bfd_asymbol_name (func);
7454
b34976b6 7455 return TRUE;
d1fad7c6
NC		 7456}
7457
7458/* Find the nearest line to a particular section and offset,
7459 for error reporting. */
7460
b34976b6 7461bfd_boolean
217aa764
AM		 7462_bfd_elf_find_nearest_line (bfd *abfd,
7463 asection *section,
7464 asymbol **symbols,
7465 bfd_vma offset,
7466 const char **filename_ptr,
7467 const char **functionname_ptr,
7468 unsigned int *line_ptr)
d1fad7c6 7469{
b34976b6 7470 bfd_boolean found;
d1fad7c6
NC		 7471
7472 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 7473 filename_ptr, functionname_ptr,
7474 line_ptr))
d1fad7c6
NC		 7475 {
7476 if (!*functionname_ptr)
4e8a9624
AM		 7477 elf_find_function (abfd, section, symbols, offset,
7478 *filename_ptr ? NULL : filename_ptr,
7479 functionname_ptr);
7480
b34976b6 7481 return TRUE;
d1fad7c6
NC		 7482 }
7483
fc28f9aa
TG		 7484 if (_bfd_dwarf2_find_nearest_line (abfd, dwarf_debug_sections,
7485 section, symbols, offset,
4e8a9624
AM		 7486 filename_ptr, functionname_ptr,
7487 line_ptr, 0,
7488 &elf_tdata (abfd)->dwarf2_find_line_info))
d1fad7c6
NC		 7489 {
7490 if (!*functionname_ptr)
4e8a9624
AM		 7491 elf_find_function (abfd, section, symbols, offset,
7492 *filename_ptr ? NULL : filename_ptr,
7493 functionname_ptr);
7494
b34976b6 7495 return TRUE;
d1fad7c6
NC		 7496 }
7497
7498 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM		 7499 &found, filename_ptr,
7500 functionname_ptr, line_ptr,
7501 &elf_tdata (abfd)->line_info))
b34976b6 7502 return FALSE;
dc43ada5 7503 if (found && (*functionname_ptr || *line_ptr))
b34976b6 7504 return TRUE;
d1fad7c6
NC		 7505
7506 if (symbols == NULL)
b34976b6 7507 return FALSE;
d1fad7c6
NC		 7508
7509 if (! elf_find_function (abfd, section, symbols, offset,
4e8a9624 7510 filename_ptr, functionname_ptr))
b34976b6 7511 return FALSE;
d1fad7c6 7512
252b5132 7513 *line_ptr = 0;
b34976b6 7514 return TRUE;
252b5132
RH		 7515}
7516
5420f73d
L		 7517/* Find the line for a symbol. */
7518
7519bfd_boolean
7520_bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7521 const char **filename_ptr, unsigned int *line_ptr)
7522{
7523 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7524 filename_ptr, line_ptr, 0,
7525 &elf_tdata (abfd)->dwarf2_find_line_info);
7526}
7527
4ab527b0
FF		 7528/* After a call to bfd_find_nearest_line, successive calls to
7529 bfd_find_inliner_info can be used to get source information about
7530 each level of function inlining that terminated at the address
7531 passed to bfd_find_nearest_line. Currently this is only supported
7532 for DWARF2 with appropriate DWARF3 extensions. */
7533
7534bfd_boolean
7535_bfd_elf_find_inliner_info (bfd *abfd,
7536 const char **filename_ptr,
7537 const char **functionname_ptr,
7538 unsigned int *line_ptr)
7539{
7540 bfd_boolean found;
7541 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7542 functionname_ptr, line_ptr,
7543 & elf_tdata (abfd)->dwarf2_find_line_info);
7544 return found;
7545}
7546
252b5132 7547int
a6b96beb 7548_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
252b5132 7549{
8ded5a0f
AM		 7550 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7551 int ret = bed->s->sizeof_ehdr;
252b5132 7552
a6b96beb 7553 if (!info->relocatable)
8ded5a0f 7554 {
62d7a5f6 7555 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
8ded5a0f 7556
62d7a5f6
AM		 7557 if (phdr_size == (bfd_size_type) -1)
7558 {
7559 struct elf_segment_map *m;
7560
7561 phdr_size = 0;
7562 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7563 phdr_size += bed->s->sizeof_phdr;
8ded5a0f 7564
62d7a5f6
AM		 7565 if (phdr_size == 0)
7566 phdr_size = get_program_header_size (abfd, info);
7567 }
8ded5a0f
AM		 7568
7569 elf_tdata (abfd)->program_header_size = phdr_size;
7570 ret += phdr_size;
7571 }
7572
252b5132
RH		 7573 return ret;
7574}
7575
b34976b6 7576bfd_boolean
217aa764
AM		 7577_bfd_elf_set_section_contents (bfd *abfd,
7578 sec_ptr section,
0f867abe 7579 const void *location,
217aa764
AM		 7580 file_ptr offset,
7581 bfd_size_type count)
252b5132
RH		 7582{
7583 Elf_Internal_Shdr *hdr;
dc810e39 7584 bfd_signed_vma pos;
252b5132
RH		 7585
7586 if (! abfd->output_has_begun
217aa764 7587 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 7588 return FALSE;
252b5132
RH		 7589
7590 hdr = &elf_section_data (section)->this_hdr;
dc810e39
AM		 7591 pos = hdr->sh_offset + offset;
7592 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7593 || bfd_bwrite (location, count, abfd) != count)
b34976b6 7594 return FALSE;
252b5132 7595
b34976b6 7596 return TRUE;
252b5132
RH		 7597}
7598
7599void
217aa764
AM		 7600_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7601 arelent *cache_ptr ATTRIBUTE_UNUSED,
7602 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH		 7603{
7604 abort ();
7605}
7606
252b5132
RH		 7607/* Try to convert a non-ELF reloc into an ELF one. */
7608
b34976b6 7609bfd_boolean
217aa764 7610_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 7611{
c044fabd 7612 /* Check whether we really have an ELF howto. */
252b5132
RH		 7613
7614 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7615 {
7616 bfd_reloc_code_real_type code;
7617 reloc_howto_type *howto;
7618
7619 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 7620 equivalent ELF reloc. */
252b5132
RH		 7621
7622 if (areloc->howto->pc_relative)
7623 {
7624 switch (areloc->howto->bitsize)
7625 {
7626 case 8:
7627 code = BFD_RELOC_8_PCREL;
7628 break;
7629 case 12:
7630 code = BFD_RELOC_12_PCREL;
7631 break;
7632 case 16:
7633 code = BFD_RELOC_16_PCREL;
7634 break;
7635 case 24:
7636 code = BFD_RELOC_24_PCREL;
7637 break;
7638 case 32:
7639 code = BFD_RELOC_32_PCREL;
7640 break;
7641 case 64:
7642 code = BFD_RELOC_64_PCREL;
7643 break;
7644 default:
7645 goto fail;
7646 }
7647
7648 howto = bfd_reloc_type_lookup (abfd, code);
7649
7650 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7651 {
7652 if (howto->pcrel_offset)
7653 areloc->addend += areloc->address;
7654 else
7655 areloc->addend -= areloc->address; /* addend is unsigned!! */
7656 }
7657 }
7658 else
7659 {
7660 switch (areloc->howto->bitsize)
7661 {
7662 case 8:
7663 code = BFD_RELOC_8;
7664 break;
7665 case 14:
7666 code = BFD_RELOC_14;
7667 break;
7668 case 16:
7669 code = BFD_RELOC_16;
7670 break;
7671 case 26:
7672 code = BFD_RELOC_26;
7673 break;
7674 case 32:
7675 code = BFD_RELOC_32;
7676 break;
7677 case 64:
7678 code = BFD_RELOC_64;
7679 break;
7680 default:
7681 goto fail;
7682 }
7683
7684 howto = bfd_reloc_type_lookup (abfd, code);
7685 }
7686
7687 if (howto)
7688 areloc->howto = howto;
7689 else
7690 goto fail;
7691 }
7692
b34976b6 7693 return TRUE;
252b5132
RH		 7694
7695 fail:
7696 (*_bfd_error_handler)
d003868e
AM		 7697 (_("%B: unsupported relocation type %s"),
7698 abfd, areloc->howto->name);
252b5132 7699 bfd_set_error (bfd_error_bad_value);
b34976b6 7700 return FALSE;
252b5132
RH		 7701}
7702
b34976b6 7703bfd_boolean
217aa764 7704_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132 7705{
d9071b0c
TG		 7706 struct elf_obj_tdata *tdata = elf_tdata (abfd);
7707 if (bfd_get_format (abfd) == bfd_object && tdata != NULL)
252b5132 7708 {
d9071b0c 7709 if (elf_shstrtab (abfd) != NULL)
2b0f7ef9 7710 _bfd_elf_strtab_free (elf_shstrtab (abfd));
d9071b0c 7711 _bfd_dwarf2_cleanup_debug_info (abfd, &tdata->dwarf2_find_line_info);
252b5132
RH		 7712 }
7713
7714 return _bfd_generic_close_and_cleanup (abfd);
7715}
7716
7717/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7718 in the relocation's offset. Thus we cannot allow any sort of sanity
7719 range-checking to interfere. There is nothing else to do in processing
7720 this reloc. */
7721
7722bfd_reloc_status_type
217aa764
AM		 7723_bfd_elf_rel_vtable_reloc_fn
7724 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 7725 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM		 7726 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7727 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH		 7728{
7729 return bfd_reloc_ok;
7730}
252b5132
RH		 7731\f
7732/* Elf core file support. Much of this only works on native
7733 toolchains, since we rely on knowing the
7734 machine-dependent procfs structure in order to pick
c044fabd 7735 out details about the corefile. */
252b5132
RH		 7736
7737#ifdef HAVE_SYS_PROCFS_H
16231b7b
DG		 7738/* Needed for new procfs interface on sparc-solaris. */
7739# define _STRUCTURED_PROC 1
252b5132
RH		 7740# include <sys/procfs.h>
7741#endif
7742
261b8d08
PA		 7743/* Return a PID that identifies a "thread" for threaded cores, or the
7744 PID of the main process for non-threaded cores. */
252b5132
RH		 7745
7746static int
217aa764 7747elfcore_make_pid (bfd *abfd)
252b5132 7748{
261b8d08
PA		 7749 int pid;
7750
7751 pid = elf_tdata (abfd)->core_lwpid;
7752 if (pid == 0)
7753 pid = elf_tdata (abfd)->core_pid;
7754
7755 return pid;
252b5132
RH		 7756}
7757
252b5132
RH		 7758/* If there isn't a section called NAME, make one, using
7759 data from SECT. Note, this function will generate a
7760 reference to NAME, so you shouldn't deallocate or
c044fabd 7761 overwrite it. */
252b5132 7762
b34976b6 7763static bfd_boolean
217aa764 7764elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 7765{
c044fabd 7766 asection *sect2;
252b5132
RH		 7767
7768 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 7769 return TRUE;
252b5132 7770
117ed4f8 7771 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
252b5132 7772 if (sect2 == NULL)
b34976b6 7773 return FALSE;
252b5132 7774
eea6121a 7775 sect2->size = sect->size;
252b5132 7776 sect2->filepos = sect->filepos;
252b5132 7777 sect2->alignment_power = sect->alignment_power;
b34976b6 7778 return TRUE;
252b5132
RH		 7779}
7780
bb0082d6
AM		 7781/* Create a pseudosection containing SIZE bytes at FILEPOS. This
7782 actually creates up to two pseudosections:
7783 - For the single-threaded case, a section named NAME, unless
7784 such a section already exists.
7785 - For the multi-threaded case, a section named "NAME/PID", where
7786 PID is elfcore_make_pid (abfd).
7787 Both pseudosections have identical contents. */
b34976b6 7788bfd_boolean
217aa764
AM		 7789_bfd_elfcore_make_pseudosection (bfd *abfd,
7790 char *name,
7791 size_t size,
7792 ufile_ptr filepos)
bb0082d6
AM		 7793{
7794 char buf[100];
7795 char *threaded_name;
d4c88bbb 7796 size_t len;
bb0082d6
AM		 7797 asection *sect;
7798
7799 /* Build the section name. */
7800
7801 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 7802 len = strlen (buf) + 1;
a50b1753 7803 threaded_name = (char *) bfd_alloc (abfd, len);
bb0082d6 7804 if (threaded_name == NULL)
b34976b6 7805 return FALSE;
d4c88bbb 7806 memcpy (threaded_name, buf, len);
bb0082d6 7807
117ed4f8
AM		 7808 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7809 SEC_HAS_CONTENTS);
bb0082d6 7810 if (sect == NULL)
b34976b6 7811 return FALSE;
eea6121a 7812 sect->size = size;
bb0082d6 7813 sect->filepos = filepos;
bb0082d6
AM		 7814 sect->alignment_power = 2;
7815
936e320b 7816 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM		 7817}
7818
252b5132 7819/* prstatus_t exists on:
4a938328 7820 solaris 2.5+
252b5132
RH		 7821 linux 2.[01] + glibc
7822 unixware 4.2
7823*/
7824
7825#if defined (HAVE_PRSTATUS_T)
a7b97311 7826
b34976b6 7827static bfd_boolean
217aa764 7828elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 7829{
eea6121a 7830 size_t size;
7ee38065 7831 int offset;
252b5132 7832
4a938328
MS		 7833 if (note->descsz == sizeof (prstatus_t))
7834 {
7835 prstatus_t prstat;
252b5132 7836
eea6121a 7837 size = sizeof (prstat.pr_reg);
7ee38065 7838 offset = offsetof (prstatus_t, pr_reg);
4a938328 7839 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 7840
fa49d224
NC		 7841 /* Do not overwrite the core signal if it
7842 has already been set by another thread. */
7843 if (elf_tdata (abfd)->core_signal == 0)
7844 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
261b8d08
PA		 7845 if (elf_tdata (abfd)->core_pid == 0)
7846 elf_tdata (abfd)->core_pid = prstat.pr_pid;
252b5132 7847
4a938328
MS		 7848 /* pr_who exists on:
7849 solaris 2.5+
7850 unixware 4.2
7851 pr_who doesn't exist on:
7852 linux 2.[01]
7853 */
252b5132 7854#if defined (HAVE_PRSTATUS_T_PR_WHO)
4a938328 7855 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
261b8d08
PA		 7856#else
7857 elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
252b5132 7858#endif
4a938328 7859 }
7ee38065 7860#if defined (HAVE_PRSTATUS32_T)
4a938328
MS		 7861 else if (note->descsz == sizeof (prstatus32_t))
7862 {
7863 /* 64-bit host, 32-bit corefile */
7864 prstatus32_t prstat;
7865
eea6121a 7866 size = sizeof (prstat.pr_reg);
7ee38065 7867 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS		 7868 memcpy (&prstat, note->descdata, sizeof (prstat));
7869
fa49d224
NC		 7870 /* Do not overwrite the core signal if it
7871 has already been set by another thread. */
7872 if (elf_tdata (abfd)->core_signal == 0)
7873 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
261b8d08
PA		 7874 if (elf_tdata (abfd)->core_pid == 0)
7875 elf_tdata (abfd)->core_pid = prstat.pr_pid;
4a938328
MS		 7876
7877 /* pr_who exists on:
7878 solaris 2.5+
7879 unixware 4.2
7880 pr_who doesn't exist on:
7881 linux 2.[01]
7882 */
7ee38065 7883#if defined (HAVE_PRSTATUS32_T_PR_WHO)
4a938328 7884 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
261b8d08
PA		 7885#else
7886 elf_tdata (abfd)->core_lwpid = prstat.pr_pid;
4a938328
MS		 7887#endif
7888 }
7ee38065 7889#endif /* HAVE_PRSTATUS32_T */
4a938328
MS		 7890 else
7891 {
7892 /* Fail - we don't know how to handle any other
7893 note size (ie. data object type). */
b34976b6 7894 return TRUE;
4a938328 7895 }
252b5132 7896
bb0082d6 7897 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 7898 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 7899 size, note->descpos + offset);
252b5132
RH		 7900}
7901#endif /* defined (HAVE_PRSTATUS_T) */
7902
bb0082d6 7903/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 7904static bfd_boolean
217aa764
AM		 7905elfcore_make_note_pseudosection (bfd *abfd,
7906 char *name,
7907 Elf_Internal_Note *note)
252b5132 7908{
936e320b
AM		 7909 return _bfd_elfcore_make_pseudosection (abfd, name,
7910 note->descsz, note->descpos);
252b5132
RH		 7911}
7912
ff08c6bb
JB		 7913/* There isn't a consistent prfpregset_t across platforms,
7914 but it doesn't matter, because we don't have to pick this
c044fabd
KH		 7915 data structure apart. */
7916
b34976b6 7917static bfd_boolean
217aa764 7918elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 7919{
7920 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7921}
7922
ff08c6bb 7923/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
971d4640 7924 type of NT_PRXFPREG. Just include the whole note's contents
ff08c6bb 7925 literally. */
c044fabd 7926
b34976b6 7927static bfd_boolean
217aa764 7928elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 7929{
7930 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7931}
7932
4339cae0
L		 7933/* Linux dumps the Intel XSAVE extended state in a note named "LINUX"
7934 with a note type of NT_X86_XSTATE. Just include the whole note's
7935 contents literally. */
7936
7937static bfd_boolean
7938elfcore_grok_xstatereg (bfd *abfd, Elf_Internal_Note *note)
7939{
7940 return elfcore_make_note_pseudosection (abfd, ".reg-xstate", note);
7941}
7942
97753bd5
AM		 7943static bfd_boolean
7944elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7945{
7946 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7947}
7948
89eeb0bc
LM		 7949static bfd_boolean
7950elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7951{
7952 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7953}
97753bd5 7954
0675e188
UW		 7955static bfd_boolean
7956elfcore_grok_s390_high_gprs (bfd *abfd, Elf_Internal_Note *note)
7957{
7958 return elfcore_make_note_pseudosection (abfd, ".reg-s390-high-gprs", note);
7959}
7960
d7eeb400
MS		 7961static bfd_boolean
7962elfcore_grok_s390_timer (bfd *abfd, Elf_Internal_Note *note)
7963{
7964 return elfcore_make_note_pseudosection (abfd, ".reg-s390-timer", note);
7965}
7966
7967static bfd_boolean
7968elfcore_grok_s390_todcmp (bfd *abfd, Elf_Internal_Note *note)
7969{
7970 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todcmp", note);
7971}
7972
7973static bfd_boolean
7974elfcore_grok_s390_todpreg (bfd *abfd, Elf_Internal_Note *note)
7975{
7976 return elfcore_make_note_pseudosection (abfd, ".reg-s390-todpreg", note);
7977}
7978
7979static bfd_boolean
7980elfcore_grok_s390_ctrs (bfd *abfd, Elf_Internal_Note *note)
7981{
7982 return elfcore_make_note_pseudosection (abfd, ".reg-s390-ctrs", note);
7983}
7984
7985static bfd_boolean
7986elfcore_grok_s390_prefix (bfd *abfd, Elf_Internal_Note *note)
7987{
7988 return elfcore_make_note_pseudosection (abfd, ".reg-s390-prefix", note);
7989}
7990
355b81d9
UW		 7991static bfd_boolean
7992elfcore_grok_s390_last_break (bfd *abfd, Elf_Internal_Note *note)
7993{
7994 return elfcore_make_note_pseudosection (abfd, ".reg-s390-last-break", note);
7995}
7996
7997static bfd_boolean
7998elfcore_grok_s390_system_call (bfd *abfd, Elf_Internal_Note *note)
7999{
8000 return elfcore_make_note_pseudosection (abfd, ".reg-s390-system-call", note);
8001}
8002
faa9a424
UW		 8003static bfd_boolean
8004elfcore_grok_arm_vfp (bfd *abfd, Elf_Internal_Note *note)
8005{
8006 return elfcore_make_note_pseudosection (abfd, ".reg-arm-vfp", note);
8007}
8008
252b5132 8009#if defined (HAVE_PRPSINFO_T)
4a938328 8010typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 8011#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 8012typedef prpsinfo32_t elfcore_psinfo32_t;
8013#endif
252b5132
RH		 8014#endif
8015
8016#if defined (HAVE_PSINFO_T)
4a938328 8017typedef psinfo_t elfcore_psinfo_t;
7ee38065 8018#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 8019typedef psinfo32_t elfcore_psinfo32_t;
8020#endif
252b5132
RH		 8021#endif
8022
252b5132
RH		 8023/* return a malloc'ed copy of a string at START which is at
8024 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 8025 the copy will always have a terminating '\0'. */
252b5132 8026
936e320b 8027char *
217aa764 8028_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 8029{
dc810e39 8030 char *dups;
a50b1753 8031 char *end = (char *) memchr (start, '\0', max);
dc810e39 8032 size_t len;
252b5132
RH		 8033
8034 if (end == NULL)
8035 len = max;
8036 else
8037 len = end - start;
8038
a50b1753 8039 dups = (char *) bfd_alloc (abfd, len + 1);
dc810e39 8040 if (dups == NULL)
252b5132
RH		 8041 return NULL;
8042
dc810e39
AM		 8043 memcpy (dups, start, len);
8044 dups[len] = '\0';
252b5132 8045
dc810e39 8046 return dups;
252b5132
RH		 8047}
8048
bb0082d6 8049#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 8050static bfd_boolean
217aa764 8051elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 8052{
4a938328
MS		 8053 if (note->descsz == sizeof (elfcore_psinfo_t))
8054 {
8055 elfcore_psinfo_t psinfo;
252b5132 8056
7ee38065 8057 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 8058
335e41d4 8059#if defined (HAVE_PSINFO_T_PR_PID) || defined (HAVE_PRPSINFO_T_PR_PID)
bc989cdc 8060 elf_tdata (abfd)->core_pid = psinfo.pr_pid;
335e41d4 8061#endif
4a938328 8062 elf_tdata (abfd)->core_program
936e320b
AM		 8063 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8064 sizeof (psinfo.pr_fname));
252b5132 8065
4a938328 8066 elf_tdata (abfd)->core_command
936e320b
AM		 8067 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8068 sizeof (psinfo.pr_psargs));
4a938328 8069 }
7ee38065 8070#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS		 8071 else if (note->descsz == sizeof (elfcore_psinfo32_t))
8072 {
8073 /* 64-bit host, 32-bit corefile */
8074 elfcore_psinfo32_t psinfo;
8075
7ee38065 8076 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 8077
335e41d4 8078#if defined (HAVE_PSINFO32_T_PR_PID) || defined (HAVE_PRPSINFO32_T_PR_PID)
bc989cdc 8079 elf_tdata (abfd)->core_pid = psinfo.pr_pid;
335e41d4 8080#endif
4a938328 8081 elf_tdata (abfd)->core_program
936e320b
AM		 8082 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
8083 sizeof (psinfo.pr_fname));
4a938328
MS		 8084
8085 elf_tdata (abfd)->core_command
936e320b
AM		 8086 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
8087 sizeof (psinfo.pr_psargs));
4a938328
MS		 8088 }
8089#endif
8090
8091 else
8092 {
8093 /* Fail - we don't know how to handle any other
8094 note size (ie. data object type). */
b34976b6 8095 return TRUE;
4a938328 8096 }
252b5132
RH		 8097
8098 /* Note that for some reason, a spurious space is tacked
8099 onto the end of the args in some (at least one anyway)
c044fabd 8100 implementations, so strip it off if it exists. */
252b5132
RH		 8101
8102 {
c044fabd 8103 char *command = elf_tdata (abfd)->core_command;
252b5132
RH		 8104 int n = strlen (command);
8105
8106 if (0 < n && command[n - 1] == ' ')
8107 command[n - 1] = '\0';
8108 }
8109
b34976b6 8110 return TRUE;
252b5132
RH		 8111}
8112#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
8113
252b5132 8114#if defined (HAVE_PSTATUS_T)
b34976b6 8115static bfd_boolean
217aa764 8116elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 8117{
f572a39d
AM		 8118 if (note->descsz == sizeof (pstatus_t)
8119#if defined (HAVE_PXSTATUS_T)
8120 || note->descsz == sizeof (pxstatus_t)
8121#endif
8122 )
4a938328
MS		 8123 {
8124 pstatus_t pstat;
252b5132 8125
4a938328 8126 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 8127
4a938328
MS		 8128 elf_tdata (abfd)->core_pid = pstat.pr_pid;
8129 }
7ee38065 8130#if defined (HAVE_PSTATUS32_T)
4a938328
MS		 8131 else if (note->descsz == sizeof (pstatus32_t))
8132 {
8133 /* 64-bit host, 32-bit corefile */
8134 pstatus32_t pstat;
252b5132 8135
4a938328 8136 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 8137
4a938328
MS		 8138 elf_tdata (abfd)->core_pid = pstat.pr_pid;
8139 }
8140#endif
252b5132
RH		 8141 /* Could grab some more details from the "representative"
8142 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 8143 NT_LWPSTATUS note, presumably. */
252b5132 8144
b34976b6 8145 return TRUE;
252b5132
RH		 8146}
8147#endif /* defined (HAVE_PSTATUS_T) */
8148
252b5132 8149#if defined (HAVE_LWPSTATUS_T)
b34976b6 8150static bfd_boolean
217aa764 8151elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH		 8152{
8153 lwpstatus_t lwpstat;
8154 char buf[100];
c044fabd 8155 char *name;
d4c88bbb 8156 size_t len;
c044fabd 8157 asection *sect;
252b5132 8158
f572a39d
AM		 8159 if (note->descsz != sizeof (lwpstat)
8160#if defined (HAVE_LWPXSTATUS_T)
8161 && note->descsz != sizeof (lwpxstatus_t)
8162#endif
8163 )
b34976b6 8164 return TRUE;
252b5132
RH		 8165
8166 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
8167
8168 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
a1504221
JB		 8169 /* Do not overwrite the core signal if it has already been set by
8170 another thread. */
8171 if (elf_tdata (abfd)->core_signal == 0)
8172 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
252b5132 8173
c044fabd 8174 /* Make a ".reg/999" section. */
252b5132
RH		 8175
8176 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 8177 len = strlen (buf) + 1;
217aa764 8178 name = bfd_alloc (abfd, len);
252b5132 8179 if (name == NULL)
b34976b6 8180 return FALSE;
d4c88bbb 8181 memcpy (name, buf, len);
252b5132 8182
117ed4f8 8183 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 8184 if (sect == NULL)
b34976b6 8185 return FALSE;
252b5132
RH		 8186
8187#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 8188 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH		 8189 sect->filepos = note->descpos
8190 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
8191#endif
8192
8193#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 8194 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH		 8195 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
8196#endif
8197
252b5132
RH		 8198 sect->alignment_power = 2;
8199
8200 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 8201 return FALSE;
252b5132
RH		 8202
8203 /* Make a ".reg2/999" section */
8204
8205 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 8206 len = strlen (buf) + 1;
217aa764 8207 name = bfd_alloc (abfd, len);
252b5132 8208 if (name == NULL)
b34976b6 8209 return FALSE;
d4c88bbb 8210 memcpy (name, buf, len);
252b5132 8211
117ed4f8 8212 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 8213 if (sect == NULL)
b34976b6 8214 return FALSE;
252b5132
RH		 8215
8216#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 8217 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH		 8218 sect->filepos = note->descpos
8219 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
8220#endif
8221
8222#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 8223 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH		 8224 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
8225#endif
8226
252b5132
RH		 8227 sect->alignment_power = 2;
8228
936e320b 8229 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH		 8230}
8231#endif /* defined (HAVE_LWPSTATUS_T) */
8232
b34976b6 8233static bfd_boolean
217aa764 8234elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC		 8235{
8236 char buf[30];
c044fabd 8237 char *name;
d4c88bbb 8238 size_t len;
c044fabd 8239 asection *sect;
4a6636fb
PA		 8240 int type;
8241 int is_active_thread;
8242 bfd_vma base_addr;
16e9c715 8243
4a6636fb 8244 if (note->descsz < 728)
b34976b6 8245 return TRUE;
16e9c715 8246
4a6636fb
PA		 8247 if (! CONST_STRNEQ (note->namedata, "win32"))
8248 return TRUE;
8249
8250 type = bfd_get_32 (abfd, note->descdata);
c044fabd 8251
4a6636fb 8252 switch (type)
16e9c715 8253 {
4a6636fb 8254 case 1 /* NOTE_INFO_PROCESS */:
16e9c715 8255 /* FIXME: need to add ->core_command. */
4a6636fb
PA		 8256 /* process_info.pid */
8257 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
8258 /* process_info.signal */
8259 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
c044fabd 8260 break;
16e9c715 8261
4a6636fb 8262 case 2 /* NOTE_INFO_THREAD */:
16e9c715 8263 /* Make a ".reg/999" section. */
4a6636fb
PA		 8264 /* thread_info.tid */
8265 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
c044fabd 8266
d4c88bbb 8267 len = strlen (buf) + 1;
a50b1753 8268 name = (char *) bfd_alloc (abfd, len);
16e9c715 8269 if (name == NULL)
b34976b6 8270 return FALSE;
c044fabd 8271
d4c88bbb 8272 memcpy (name, buf, len);
16e9c715 8273
117ed4f8 8274 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
16e9c715 8275 if (sect == NULL)
b34976b6 8276 return FALSE;
c044fabd 8277
4a6636fb
PA		 8278 /* sizeof (thread_info.thread_context) */
8279 sect->size = 716;
8280 /* offsetof (thread_info.thread_context) */
8281 sect->filepos = note->descpos + 12;
16e9c715
NC		 8282 sect->alignment_power = 2;
8283
4a6636fb
PA		 8284 /* thread_info.is_active_thread */
8285 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
8286
8287 if (is_active_thread)
16e9c715 8288 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 8289 return FALSE;
16e9c715
NC		 8290 break;
8291
4a6636fb 8292 case 3 /* NOTE_INFO_MODULE */:
16e9c715 8293 /* Make a ".module/xxxxxxxx" section. */
4a6636fb
PA		 8294 /* module_info.base_address */
8295 base_addr = bfd_get_32 (abfd, note->descdata + 4);
0af1713e 8296 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
c044fabd 8297
d4c88bbb 8298 len = strlen (buf) + 1;
a50b1753 8299 name = (char *) bfd_alloc (abfd, len);
16e9c715 8300 if (name == NULL)
b34976b6 8301 return FALSE;
c044fabd 8302
d4c88bbb 8303 memcpy (name, buf, len);
252b5132 8304
117ed4f8 8305 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
c044fabd 8306
16e9c715 8307 if (sect == NULL)
b34976b6 8308 return FALSE;
c044fabd 8309
eea6121a 8310 sect->size = note->descsz;
16e9c715 8311 sect->filepos = note->descpos;
16e9c715
NC		 8312 sect->alignment_power = 2;
8313 break;
8314
8315 default:
b34976b6 8316 return TRUE;
16e9c715
NC		 8317 }
8318
b34976b6 8319 return TRUE;
16e9c715 8320}
252b5132 8321
b34976b6 8322static bfd_boolean
217aa764 8323elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 8324{
9c5bfbb7 8325 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 8326
252b5132
RH		 8327 switch (note->type)
8328 {
8329 default:
b34976b6 8330 return TRUE;
252b5132 8331
252b5132 8332 case NT_PRSTATUS:
bb0082d6
AM		 8333 if (bed->elf_backend_grok_prstatus)
8334 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 8335 return TRUE;
bb0082d6 8336#if defined (HAVE_PRSTATUS_T)
252b5132 8337 return elfcore_grok_prstatus (abfd, note);
bb0082d6 8338#else
b34976b6 8339 return TRUE;
252b5132
RH		 8340#endif
8341
8342#if defined (HAVE_PSTATUS_T)
8343 case NT_PSTATUS:
8344 return elfcore_grok_pstatus (abfd, note);
8345#endif
8346
8347#if defined (HAVE_LWPSTATUS_T)
8348 case NT_LWPSTATUS:
8349 return elfcore_grok_lwpstatus (abfd, note);
8350#endif
8351
8352 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
8353 return elfcore_grok_prfpreg (abfd, note);
8354
c044fabd 8355 case NT_WIN32PSTATUS:
16e9c715 8356 return elfcore_grok_win32pstatus (abfd, note);
16e9c715 8357
c044fabd 8358 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK		 8359 if (note->namesz == 6
8360 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB		 8361 return elfcore_grok_prxfpreg (abfd, note);
8362 else
b34976b6 8363 return TRUE;
ff08c6bb 8364
4339cae0
L		 8365 case NT_X86_XSTATE: /* Linux XSAVE extension */
8366 if (note->namesz == 6
8367 && strcmp (note->namedata, "LINUX") == 0)
8368 return elfcore_grok_xstatereg (abfd, note);
8369 else
8370 return TRUE;
8371
97753bd5
AM		 8372 case NT_PPC_VMX:
8373 if (note->namesz == 6
8374 && strcmp (note->namedata, "LINUX") == 0)
8375 return elfcore_grok_ppc_vmx (abfd, note);
8376 else
8377 return TRUE;
8378
89eeb0bc
LM		 8379 case NT_PPC_VSX:
8380 if (note->namesz == 6
8381 && strcmp (note->namedata, "LINUX") == 0)
8382 return elfcore_grok_ppc_vsx (abfd, note);
8383 else
8384 return TRUE;
8385
0675e188
UW		 8386 case NT_S390_HIGH_GPRS:
8387 if (note->namesz == 6
8388 && strcmp (note->namedata, "LINUX") == 0)
8389 return elfcore_grok_s390_high_gprs (abfd, note);
8390 else
8391 return TRUE;
8392
d7eeb400
MS		 8393 case NT_S390_TIMER:
8394 if (note->namesz == 6
8395 && strcmp (note->namedata, "LINUX") == 0)
8396 return elfcore_grok_s390_timer (abfd, note);
8397 else
8398 return TRUE;
8399
8400 case NT_S390_TODCMP:
8401 if (note->namesz == 6
8402 && strcmp (note->namedata, "LINUX") == 0)
8403 return elfcore_grok_s390_todcmp (abfd, note);
8404 else
8405 return TRUE;
8406
8407 case NT_S390_TODPREG:
8408 if (note->namesz == 6
8409 && strcmp (note->namedata, "LINUX") == 0)
8410 return elfcore_grok_s390_todpreg (abfd, note);
8411 else
8412 return TRUE;
8413
8414 case NT_S390_CTRS:
8415 if (note->namesz == 6
8416 && strcmp (note->namedata, "LINUX") == 0)
8417 return elfcore_grok_s390_ctrs (abfd, note);
8418 else
8419 return TRUE;
8420
8421 case NT_S390_PREFIX:
8422 if (note->namesz == 6
8423 && strcmp (note->namedata, "LINUX") == 0)
8424 return elfcore_grok_s390_prefix (abfd, note);
8425 else
8426 return TRUE;
8427
355b81d9
UW		 8428 case NT_S390_LAST_BREAK:
8429 if (note->namesz == 6
8430 && strcmp (note->namedata, "LINUX") == 0)
8431 return elfcore_grok_s390_last_break (abfd, note);
8432 else
8433 return TRUE;
8434
8435 case NT_S390_SYSTEM_CALL:
8436 if (note->namesz == 6
8437 && strcmp (note->namedata, "LINUX") == 0)
8438 return elfcore_grok_s390_system_call (abfd, note);
8439 else
8440 return TRUE;
8441
faa9a424
UW		 8442 case NT_ARM_VFP:
8443 if (note->namesz == 6
8444 && strcmp (note->namedata, "LINUX") == 0)
8445 return elfcore_grok_arm_vfp (abfd, note);
8446 else
8447 return TRUE;
8448
252b5132
RH		 8449 case NT_PRPSINFO:
8450 case NT_PSINFO:
bb0082d6
AM		 8451 if (bed->elf_backend_grok_psinfo)
8452 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 8453 return TRUE;
bb0082d6 8454#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 8455 return elfcore_grok_psinfo (abfd, note);
bb0082d6 8456#else
b34976b6 8457 return TRUE;
252b5132 8458#endif
3333a7c3
RM		 8459
8460 case NT_AUXV:
8461 {
117ed4f8
AM		 8462 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8463 SEC_HAS_CONTENTS);
3333a7c3
RM		 8464
8465 if (sect == NULL)
8466 return FALSE;
eea6121a 8467 sect->size = note->descsz;
3333a7c3 8468 sect->filepos = note->descpos;
3333a7c3
RM		 8469 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8470
8471 return TRUE;
8472 }
252b5132
RH		 8473 }
8474}
8475
718175fa
JK		 8476static bfd_boolean
8477elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
8478{
8479 elf_tdata (abfd)->build_id_size = note->descsz;
a50b1753 8480 elf_tdata (abfd)->build_id = (bfd_byte *) bfd_alloc (abfd, note->descsz);
718175fa
JK		 8481 if (elf_tdata (abfd)->build_id == NULL)
8482 return FALSE;
8483
8484 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
8485
8486 return TRUE;
8487}
8488
8489static bfd_boolean
8490elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
8491{
8492 switch (note->type)
8493 {
8494 default:
8495 return TRUE;
8496
8497 case NT_GNU_BUILD_ID:
8498 return elfobj_grok_gnu_build_id (abfd, note);
8499 }
8500}
8501
e21e5835
NC		 8502static bfd_boolean
8503elfobj_grok_stapsdt_note_1 (bfd *abfd, Elf_Internal_Note *note)
8504{
8505 struct sdt_note *cur =
8506 (struct sdt_note *) bfd_alloc (abfd, sizeof (struct sdt_note)
8507 + note->descsz);
8508
8509 cur->next = (struct sdt_note *) (elf_tdata (abfd))->sdt_note_head;
8510 cur->size = (bfd_size_type) note->descsz;
8511 memcpy (cur->data, note->descdata, note->descsz);
8512
8513 elf_tdata (abfd)->sdt_note_head = cur;
8514
8515 return TRUE;
8516}
8517
8518static bfd_boolean
8519elfobj_grok_stapsdt_note (bfd *abfd, Elf_Internal_Note *note)
8520{
8521 switch (note->type)
8522 {
8523 case NT_STAPSDT:
8524 return elfobj_grok_stapsdt_note_1 (abfd, note);
8525
8526 default:
8527 return TRUE;
8528 }
8529}
8530
b34976b6 8531static bfd_boolean
217aa764 8532elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM		 8533{
8534 char *cp;
8535
8536 cp = strchr (note->namedata, '@');
8537 if (cp != NULL)
8538 {
d2b64500 8539 *lwpidp = atoi(cp + 1);
b34976b6 8540 return TRUE;
50b2bdb7 8541 }
b34976b6 8542 return FALSE;
50b2bdb7
AM		 8543}
8544
b34976b6 8545static bfd_boolean
217aa764 8546elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7 8547{
50b2bdb7
AM		 8548 /* Signal number at offset 0x08. */
8549 elf_tdata (abfd)->core_signal
8550 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8551
8552 /* Process ID at offset 0x50. */
8553 elf_tdata (abfd)->core_pid
8554 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8555
8556 /* Command name at 0x7c (max 32 bytes, including nul). */
8557 elf_tdata (abfd)->core_command
8558 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8559
7720ba9f
MK		 8560 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8561 note);
50b2bdb7
AM		 8562}
8563
b34976b6 8564static bfd_boolean
217aa764 8565elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 8566{
8567 int lwp;
8568
8569 if (elfcore_netbsd_get_lwpid (note, &lwp))
8570 elf_tdata (abfd)->core_lwpid = lwp;
8571
b4db1224 8572 if (note->type == NT_NETBSDCORE_PROCINFO)
50b2bdb7
AM		 8573 {
8574 /* NetBSD-specific core "procinfo". Note that we expect to
08a40648
AM		 8575 find this note before any of the others, which is fine,
8576 since the kernel writes this note out first when it
8577 creates a core file. */
47d9a591 8578
50b2bdb7
AM		 8579 return elfcore_grok_netbsd_procinfo (abfd, note);
8580 }
8581
b4db1224
JT		 8582 /* As of Jan 2002 there are no other machine-independent notes
8583 defined for NetBSD core files. If the note type is less
8584 than the start of the machine-dependent note types, we don't
8585 understand it. */
47d9a591 8586
b4db1224 8587 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 8588 return TRUE;
50b2bdb7
AM		 8589
8590
8591 switch (bfd_get_arch (abfd))
8592 {
08a40648
AM		 8593 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8594 PT_GETFPREGS == mach+2. */
50b2bdb7
AM		 8595
8596 case bfd_arch_alpha:
8597 case bfd_arch_sparc:
8598 switch (note->type)
08a40648
AM		 8599 {
8600 case NT_NETBSDCORE_FIRSTMACH+0:
8601 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 8602
08a40648
AM		 8603 case NT_NETBSDCORE_FIRSTMACH+2:
8604 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 8605
08a40648
AM		 8606 default:
8607 return TRUE;
8608 }
50b2bdb7 8609
08a40648
AM		 8610 /* On all other arch's, PT_GETREGS == mach+1 and
8611 PT_GETFPREGS == mach+3. */
50b2bdb7
AM		 8612
8613 default:
8614 switch (note->type)
08a40648
AM		 8615 {
8616 case NT_NETBSDCORE_FIRSTMACH+1:
8617 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 8618
08a40648
AM		 8619 case NT_NETBSDCORE_FIRSTMACH+3:
8620 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 8621
08a40648
AM		 8622 default:
8623 return TRUE;
8624 }
50b2bdb7
AM		 8625 }
8626 /* NOTREACHED */
8627}
8628
67cc5033
MK		 8629static bfd_boolean
8630elfcore_grok_openbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
8631{
8632 /* Signal number at offset 0x08. */
8633 elf_tdata (abfd)->core_signal
8634 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8635
8636 /* Process ID at offset 0x20. */
8637 elf_tdata (abfd)->core_pid
8638 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x20);
8639
8640 /* Command name at 0x48 (max 32 bytes, including nul). */
8641 elf_tdata (abfd)->core_command
8642 = _bfd_elfcore_strndup (abfd, note->descdata + 0x48, 31);
8643
8644 return TRUE;
8645}
8646
8647static bfd_boolean
8648elfcore_grok_openbsd_note (bfd *abfd, Elf_Internal_Note *note)
8649{
8650 if (note->type == NT_OPENBSD_PROCINFO)
8651 return elfcore_grok_openbsd_procinfo (abfd, note);
8652
8653 if (note->type == NT_OPENBSD_REGS)
8654 return elfcore_make_note_pseudosection (abfd, ".reg", note);
8655
8656 if (note->type == NT_OPENBSD_FPREGS)
8657 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
8658
8659 if (note->type == NT_OPENBSD_XFPREGS)
8660 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
8661
8662 if (note->type == NT_OPENBSD_AUXV)
8663 {
8664 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
8665 SEC_HAS_CONTENTS);
8666
8667 if (sect == NULL)
8668 return FALSE;
8669 sect->size = note->descsz;
8670 sect->filepos = note->descpos;
8671 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8672
8673 return TRUE;
8674 }
8675
8676 if (note->type == NT_OPENBSD_WCOOKIE)
8677 {
8678 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".wcookie",
8679 SEC_HAS_CONTENTS);
8680
8681 if (sect == NULL)
8682 return FALSE;
8683 sect->size = note->descsz;
8684 sect->filepos = note->descpos;
8685 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
8686
8687 return TRUE;
8688 }
8689
8690 return TRUE;
8691}
8692
07c6e936 8693static bfd_boolean
d3fd4074 8694elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
07c6e936
NC		 8695{
8696 void *ddata = note->descdata;
8697 char buf[100];
8698 char *name;
8699 asection *sect;
f8843e87
AM		 8700 short sig;
8701 unsigned flags;
07c6e936
NC		 8702
8703 /* nto_procfs_status 'pid' field is at offset 0. */
8704 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8705
f8843e87
AM		 8706 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8707 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8708
8709 /* nto_procfs_status 'flags' field is at offset 8. */
8710 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC		 8711
8712 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM		 8713 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8714 {
8715 elf_tdata (abfd)->core_signal = sig;
8716 elf_tdata (abfd)->core_lwpid = *tid;
8717 }
07c6e936 8718
f8843e87
AM		 8719 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8720 do not come from signals so we make sure we set the current
8721 thread just in case. */
8722 if (flags & 0x00000080)
8723 elf_tdata (abfd)->core_lwpid = *tid;
07c6e936
NC		 8724
8725 /* Make a ".qnx_core_status/%d" section. */
d3fd4074 8726 sprintf (buf, ".qnx_core_status/%ld", *tid);
07c6e936 8727
a50b1753 8728 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 8729 if (name == NULL)
8730 return FALSE;
8731 strcpy (name, buf);
8732
117ed4f8 8733 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 8734 if (sect == NULL)
8735 return FALSE;
8736
eea6121a 8737 sect->size = note->descsz;
07c6e936 8738 sect->filepos = note->descpos;
07c6e936
NC		 8739 sect->alignment_power = 2;
8740
8741 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8742}
8743
8744static bfd_boolean
d69f560c
KW		 8745elfcore_grok_nto_regs (bfd *abfd,
8746 Elf_Internal_Note *note,
d3fd4074 8747 long tid,
d69f560c 8748 char *base)
07c6e936
NC		 8749{
8750 char buf[100];
8751 char *name;
8752 asection *sect;
8753
d69f560c 8754 /* Make a "(base)/%d" section. */
d3fd4074 8755 sprintf (buf, "%s/%ld", base, tid);
07c6e936 8756
a50b1753 8757 name = (char *) bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 8758 if (name == NULL)
8759 return FALSE;
8760 strcpy (name, buf);
8761
117ed4f8 8762 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 8763 if (sect == NULL)
8764 return FALSE;
8765
eea6121a 8766 sect->size = note->descsz;
07c6e936 8767 sect->filepos = note->descpos;
07c6e936
NC		 8768 sect->alignment_power = 2;
8769
f8843e87
AM		 8770 /* This is the current thread. */
8771 if (elf_tdata (abfd)->core_lwpid == tid)
d69f560c 8772 return elfcore_maybe_make_sect (abfd, base, sect);
f8843e87
AM		 8773
8774 return TRUE;
07c6e936
NC		 8775}
8776
8777#define BFD_QNT_CORE_INFO 7
8778#define BFD_QNT_CORE_STATUS 8
8779#define BFD_QNT_CORE_GREG 9
8780#define BFD_QNT_CORE_FPREG 10
8781
8782static bfd_boolean
217aa764 8783elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC		 8784{
8785 /* Every GREG section has a STATUS section before it. Store the
811072d8 8786 tid from the previous call to pass down to the next gregs
07c6e936 8787 function. */
d3fd4074 8788 static long tid = 1;
07c6e936
NC		 8789
8790 switch (note->type)
8791 {
d69f560c
KW		 8792 case BFD_QNT_CORE_INFO:
8793 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8794 case BFD_QNT_CORE_STATUS:
8795 return elfcore_grok_nto_status (abfd, note, &tid);
8796 case BFD_QNT_CORE_GREG:
8797 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8798 case BFD_QNT_CORE_FPREG:
8799 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8800 default:
8801 return TRUE;
07c6e936
NC		 8802 }
8803}
8804
b15fa79e
AM		 8805static bfd_boolean
8806elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8807{
8808 char *name;
8809 asection *sect;
8810 size_t len;
8811
8812 /* Use note name as section name. */
8813 len = note->namesz;
a50b1753 8814 name = (char *) bfd_alloc (abfd, len);
b15fa79e
AM		 8815 if (name == NULL)
8816 return FALSE;
8817 memcpy (name, note->namedata, len);
8818 name[len - 1] = '\0';
8819
8820 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8821 if (sect == NULL)
8822 return FALSE;
8823
8824 sect->size = note->descsz;
8825 sect->filepos = note->descpos;
8826 sect->alignment_power = 1;
8827
8828 return TRUE;
8829}
8830
7c76fa91
MS		 8831/* Function: elfcore_write_note
8832
47d9a591 8833 Inputs:
a39f3346 8834 buffer to hold note, and current size of buffer
7c76fa91
MS		 8835 name of note
8836 type of note
8837 data for note
8838 size of data for note
8839
a39f3346
AM		 8840 Writes note to end of buffer. ELF64 notes are written exactly as
8841 for ELF32, despite the current (as of 2006) ELF gabi specifying
8842 that they ought to have 8-byte namesz and descsz field, and have
8843 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8844
7c76fa91 8845 Return:
a39f3346 8846 Pointer to realloc'd buffer, *BUFSIZ updated. */
7c76fa91
MS		 8847
8848char *
a39f3346 8849elfcore_write_note (bfd *abfd,
217aa764 8850 char *buf,
a39f3346 8851 int *bufsiz,
217aa764 8852 const char *name,
a39f3346 8853 int type,
217aa764 8854 const void *input,
a39f3346 8855 int size)
7c76fa91
MS		 8856{
8857 Elf_External_Note *xnp;
d4c88bbb 8858 size_t namesz;
d4c88bbb 8859 size_t newspace;
a39f3346 8860 char *dest;
7c76fa91 8861
d4c88bbb 8862 namesz = 0;
d4c88bbb 8863 if (name != NULL)
a39f3346 8864 namesz = strlen (name) + 1;
d4c88bbb 8865
a39f3346 8866 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
d4c88bbb 8867
a50b1753 8868 buf = (char *) realloc (buf, *bufsiz + newspace);
14b1c01e
AM		 8869 if (buf == NULL)
8870 return buf;
a39f3346 8871 dest = buf + *bufsiz;
7c76fa91
MS		 8872 *bufsiz += newspace;
8873 xnp = (Elf_External_Note *) dest;
8874 H_PUT_32 (abfd, namesz, xnp->namesz);
8875 H_PUT_32 (abfd, size, xnp->descsz);
8876 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM		 8877 dest = xnp->name;
8878 if (name != NULL)
8879 {
8880 memcpy (dest, name, namesz);
8881 dest += namesz;
a39f3346 8882 while (namesz & 3)
d4c88bbb
AM		 8883 {
8884 *dest++ = '\0';
a39f3346 8885 ++namesz;
d4c88bbb
AM		 8886 }
8887 }
8888 memcpy (dest, input, size);
a39f3346
AM		 8889 dest += size;
8890 while (size & 3)
8891 {
8892 *dest++ = '\0';
8893 ++size;
8894 }
8895 return buf;
7c76fa91
MS		 8896}
8897
7c76fa91 8898char *
217aa764
AM		 8899elfcore_write_prpsinfo (bfd *abfd,
8900 char *buf,
8901 int *bufsiz,
8902 const char *fname,
8903 const char *psargs)
7c76fa91 8904{
183e98be
AM		 8905 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8906
8907 if (bed->elf_backend_write_core_note != NULL)
8908 {
8909 char *ret;
8910 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8911 NT_PRPSINFO, fname, psargs);
8912 if (ret != NULL)
8913 return ret;
8914 }
7c76fa91 8915
1f20dca5 8916#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
183e98be
AM		 8917#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8918 if (bed->s->elfclass == ELFCLASS32)
8919 {
8920#if defined (HAVE_PSINFO32_T)
8921 psinfo32_t data;
8922 int note_type = NT_PSINFO;
8923#else
8924 prpsinfo32_t data;
8925 int note_type = NT_PRPSINFO;
8926#endif
8927
8928 memset (&data, 0, sizeof (data));
8929 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8930 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8931 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 8932 "CORE", note_type, &data, sizeof (data));
183e98be
AM		 8933 }
8934 else
8935#endif
8936 {
7c76fa91 8937#if defined (HAVE_PSINFO_T)
183e98be
AM		 8938 psinfo_t data;
8939 int note_type = NT_PSINFO;
7c76fa91 8940#else
183e98be
AM		 8941 prpsinfo_t data;
8942 int note_type = NT_PRPSINFO;
7c76fa91
MS		 8943#endif
8944
183e98be
AM		 8945 memset (&data, 0, sizeof (data));
8946 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8947 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8948 return elfcore_write_note (abfd, buf, bufsiz,
1f20dca5 8949 "CORE", note_type, &data, sizeof (data));
183e98be 8950 }
7c76fa91
MS		 8951#endif /* PSINFO_T or PRPSINFO_T */
8952
1f20dca5
UW		 8953 free (buf);
8954 return NULL;
8955}
8956
7c76fa91 8957char *
217aa764
AM		 8958elfcore_write_prstatus (bfd *abfd,
8959 char *buf,
8960 int *bufsiz,
8961 long pid,
8962 int cursig,
8963 const void *gregs)
7c76fa91 8964{
183e98be 8965 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 8966
183e98be
AM		 8967 if (bed->elf_backend_write_core_note != NULL)
8968 {
8969 char *ret;
8970 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8971 NT_PRSTATUS,
8972 pid, cursig, gregs);
8973 if (ret != NULL)
8974 return ret;
8975 }
8976
1f20dca5 8977#if defined (HAVE_PRSTATUS_T)
183e98be
AM		 8978#if defined (HAVE_PRSTATUS32_T)
8979 if (bed->s->elfclass == ELFCLASS32)
8980 {
8981 prstatus32_t prstat;
8982
8983 memset (&prstat, 0, sizeof (prstat));
8984 prstat.pr_pid = pid;
8985 prstat.pr_cursig = cursig;
8986 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 8987 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM		 8988 NT_PRSTATUS, &prstat, sizeof (prstat));
8989 }
8990 else
8991#endif
8992 {
8993 prstatus_t prstat;
8994
8995 memset (&prstat, 0, sizeof (prstat));
8996 prstat.pr_pid = pid;
8997 prstat.pr_cursig = cursig;
8998 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
1f20dca5 8999 return elfcore_write_note (abfd, buf, bufsiz, "CORE",
183e98be
AM		 9000 NT_PRSTATUS, &prstat, sizeof (prstat));
9001 }
7c76fa91
MS		 9002#endif /* HAVE_PRSTATUS_T */
9003
1f20dca5
UW		 9004 free (buf);
9005 return NULL;
9006}
9007
51316059
MS		 9008#if defined (HAVE_LWPSTATUS_T)
9009char *
217aa764
AM		 9010elfcore_write_lwpstatus (bfd *abfd,
9011 char *buf,
9012 int *bufsiz,
9013 long pid,
9014 int cursig,
9015 const void *gregs)
51316059
MS		 9016{
9017 lwpstatus_t lwpstat;
183e98be 9018 const char *note_name = "CORE";
51316059
MS		 9019
9020 memset (&lwpstat, 0, sizeof (lwpstat));
9021 lwpstat.pr_lwpid = pid >> 16;
9022 lwpstat.pr_cursig = cursig;
9023#if defined (HAVE_LWPSTATUS_T_PR_REG)
9024 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
9025#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
9026#if !defined(gregs)
9027 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
9028 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
9029#else
9030 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
9031 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
9032#endif
9033#endif
47d9a591 9034 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 9035 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
9036}
9037#endif /* HAVE_LWPSTATUS_T */
9038
7c76fa91
MS		 9039#if defined (HAVE_PSTATUS_T)
9040char *
217aa764
AM		 9041elfcore_write_pstatus (bfd *abfd,
9042 char *buf,
9043 int *bufsiz,
9044 long pid,
6c10990d
NC		 9045 int cursig ATTRIBUTE_UNUSED,
9046 const void *gregs ATTRIBUTE_UNUSED)
7c76fa91 9047{
183e98be
AM		 9048 const char *note_name = "CORE";
9049#if defined (HAVE_PSTATUS32_T)
9050 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 9051
183e98be
AM		 9052 if (bed->s->elfclass == ELFCLASS32)
9053 {
9054 pstatus32_t pstat;
9055
9056 memset (&pstat, 0, sizeof (pstat));
9057 pstat.pr_pid = pid & 0xffff;
9058 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9059 NT_PSTATUS, &pstat, sizeof (pstat));
9060 return buf;
9061 }
9062 else
9063#endif
9064 {
9065 pstatus_t pstat;
9066
9067 memset (&pstat, 0, sizeof (pstat));
9068 pstat.pr_pid = pid & 0xffff;
9069 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
9070 NT_PSTATUS, &pstat, sizeof (pstat));
9071 return buf;
9072 }
7c76fa91
MS		 9073}
9074#endif /* HAVE_PSTATUS_T */
9075
9076char *
217aa764
AM		 9077elfcore_write_prfpreg (bfd *abfd,
9078 char *buf,
9079 int *bufsiz,
9080 const void *fpregs,
9081 int size)
7c76fa91 9082{
183e98be 9083 const char *note_name = "CORE";
47d9a591 9084 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 9085 note_name, NT_FPREGSET, fpregs, size);
9086}
9087
9088char *
217aa764
AM		 9089elfcore_write_prxfpreg (bfd *abfd,
9090 char *buf,
9091 int *bufsiz,
9092 const void *xfpregs,
9093 int size)
7c76fa91
MS		 9094{
9095 char *note_name = "LINUX";
47d9a591 9096 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 9097 note_name, NT_PRXFPREG, xfpregs, size);
9098}
9099
4339cae0
L		 9100char *
9101elfcore_write_xstatereg (bfd *abfd, char *buf, int *bufsiz,
9102 const void *xfpregs, int size)
9103{
9104 char *note_name = "LINUX";
9105 return elfcore_write_note (abfd, buf, bufsiz,
9106 note_name, NT_X86_XSTATE, xfpregs, size);
9107}
9108
97753bd5
AM		 9109char *
9110elfcore_write_ppc_vmx (bfd *abfd,
9111 char *buf,
9112 int *bufsiz,
9113 const void *ppc_vmx,
9114 int size)
9115{
9116 char *note_name = "LINUX";
9117 return elfcore_write_note (abfd, buf, bufsiz,
9118 note_name, NT_PPC_VMX, ppc_vmx, size);
9119}
9120
89eeb0bc
LM		 9121char *
9122elfcore_write_ppc_vsx (bfd *abfd,
9123 char *buf,
9124 int *bufsiz,
9125 const void *ppc_vsx,
9126 int size)
9127{
9128 char *note_name = "LINUX";
9129 return elfcore_write_note (abfd, buf, bufsiz,
9130 note_name, NT_PPC_VSX, ppc_vsx, size);
9131}
9132
0675e188
UW		 9133static char *
9134elfcore_write_s390_high_gprs (bfd *abfd,
9135 char *buf,
9136 int *bufsiz,
9137 const void *s390_high_gprs,
9138 int size)
9139{
9140 char *note_name = "LINUX";
9141 return elfcore_write_note (abfd, buf, bufsiz,
9142 note_name, NT_S390_HIGH_GPRS,
9143 s390_high_gprs, size);
9144}
9145
d7eeb400
MS		 9146char *
9147elfcore_write_s390_timer (bfd *abfd,
9148 char *buf,
9149 int *bufsiz,
9150 const void *s390_timer,
9151 int size)
9152{
9153 char *note_name = "LINUX";
9154 return elfcore_write_note (abfd, buf, bufsiz,
9155 note_name, NT_S390_TIMER, s390_timer, size);
9156}
9157
9158char *
9159elfcore_write_s390_todcmp (bfd *abfd,
9160 char *buf,
9161 int *bufsiz,
9162 const void *s390_todcmp,
9163 int size)
9164{
9165 char *note_name = "LINUX";
9166 return elfcore_write_note (abfd, buf, bufsiz,
9167 note_name, NT_S390_TODCMP, s390_todcmp, size);
9168}
9169
9170char *
9171elfcore_write_s390_todpreg (bfd *abfd,
9172 char *buf,
9173 int *bufsiz,
9174 const void *s390_todpreg,
9175 int size)
9176{
9177 char *note_name = "LINUX";
9178 return elfcore_write_note (abfd, buf, bufsiz,
9179 note_name, NT_S390_TODPREG, s390_todpreg, size);
9180}
9181
9182char *
9183elfcore_write_s390_ctrs (bfd *abfd,
9184 char *buf,
9185 int *bufsiz,
9186 const void *s390_ctrs,
9187 int size)
9188{
9189 char *note_name = "LINUX";
9190 return elfcore_write_note (abfd, buf, bufsiz,
9191 note_name, NT_S390_CTRS, s390_ctrs, size);
9192}
9193
9194char *
9195elfcore_write_s390_prefix (bfd *abfd,
9196 char *buf,
9197 int *bufsiz,
9198 const void *s390_prefix,
9199 int size)
9200{
9201 char *note_name = "LINUX";
9202 return elfcore_write_note (abfd, buf, bufsiz,
9203 note_name, NT_S390_PREFIX, s390_prefix, size);
9204}
9205
355b81d9
UW		 9206char *
9207elfcore_write_s390_last_break (bfd *abfd,
9208 char *buf,
9209 int *bufsiz,
9210 const void *s390_last_break,
9211 int size)
9212{
9213 char *note_name = "LINUX";
9214 return elfcore_write_note (abfd, buf, bufsiz,
9215 note_name, NT_S390_LAST_BREAK,
9216 s390_last_break, size);
9217}
9218
9219char *
9220elfcore_write_s390_system_call (bfd *abfd,
9221 char *buf,
9222 int *bufsiz,
9223 const void *s390_system_call,
9224 int size)
9225{
9226 char *note_name = "LINUX";
9227 return elfcore_write_note (abfd, buf, bufsiz,
9228 note_name, NT_S390_SYSTEM_CALL,
9229 s390_system_call, size);
9230}
9231
faa9a424
UW		 9232char *
9233elfcore_write_arm_vfp (bfd *abfd,
9234 char *buf,
9235 int *bufsiz,
9236 const void *arm_vfp,
9237 int size)
9238{
9239 char *note_name = "LINUX";
9240 return elfcore_write_note (abfd, buf, bufsiz,
9241 note_name, NT_ARM_VFP, arm_vfp, size);
9242}
9243
bb864ac1
CES		 9244char *
9245elfcore_write_register_note (bfd *abfd,
9246 char *buf,
9247 int *bufsiz,
9248 const char *section,
9249 const void *data,
9250 int size)
9251{
9252 if (strcmp (section, ".reg2") == 0)
9253 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
9254 if (strcmp (section, ".reg-xfp") == 0)
9255 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
4339cae0
L		 9256 if (strcmp (section, ".reg-xstate") == 0)
9257 return elfcore_write_xstatereg (abfd, buf, bufsiz, data, size);
bb864ac1
CES		 9258 if (strcmp (section, ".reg-ppc-vmx") == 0)
9259 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
89eeb0bc
LM		 9260 if (strcmp (section, ".reg-ppc-vsx") == 0)
9261 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
0675e188
UW		 9262 if (strcmp (section, ".reg-s390-high-gprs") == 0)
9263 return elfcore_write_s390_high_gprs (abfd, buf, bufsiz, data, size);
d7eeb400
MS		 9264 if (strcmp (section, ".reg-s390-timer") == 0)
9265 return elfcore_write_s390_timer (abfd, buf, bufsiz, data, size);
9266 if (strcmp (section, ".reg-s390-todcmp") == 0)
9267 return elfcore_write_s390_todcmp (abfd, buf, bufsiz, data, size);
9268 if (strcmp (section, ".reg-s390-todpreg") == 0)
9269 return elfcore_write_s390_todpreg (abfd, buf, bufsiz, data, size);
9270 if (strcmp (section, ".reg-s390-ctrs") == 0)
9271 return elfcore_write_s390_ctrs (abfd, buf, bufsiz, data, size);
9272 if (strcmp (section, ".reg-s390-prefix") == 0)
9273 return elfcore_write_s390_prefix (abfd, buf, bufsiz, data, size);
355b81d9
UW		 9274 if (strcmp (section, ".reg-s390-last-break") == 0)
9275 return elfcore_write_s390_last_break (abfd, buf, bufsiz, data, size);
9276 if (strcmp (section, ".reg-s390-system-call") == 0)
9277 return elfcore_write_s390_system_call (abfd, buf, bufsiz, data, size);
faa9a424
UW		 9278 if (strcmp (section, ".reg-arm-vfp") == 0)
9279 return elfcore_write_arm_vfp (abfd, buf, bufsiz, data, size);
bb864ac1
CES		 9280 return NULL;
9281}
9282
b34976b6 9283static bfd_boolean
718175fa 9284elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
252b5132 9285{
c044fabd 9286 char *p;
252b5132 9287
252b5132
RH		 9288 p = buf;
9289 while (p < buf + size)
9290 {
c044fabd
KH		 9291 /* FIXME: bad alignment assumption. */
9292 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH		 9293 Elf_Internal_Note in;
9294
baea7ef1
AM		 9295 if (offsetof (Elf_External_Note, name) > buf - p + size)
9296 return FALSE;
9297
dc810e39 9298 in.type = H_GET_32 (abfd, xnp->type);
252b5132 9299
dc810e39 9300 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132 9301 in.namedata = xnp->name;
baea7ef1
AM		 9302 if (in.namesz > buf - in.namedata + size)
9303 return FALSE;
252b5132 9304
dc810e39 9305 in.descsz = H_GET_32 (abfd, xnp->descsz);
252b5132
RH		 9306 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
9307 in.descpos = offset + (in.descdata - buf);
baea7ef1
AM		 9308 if (in.descsz != 0
9309 && (in.descdata >= buf + size
9310 || in.descsz > buf - in.descdata + size))
9311 return FALSE;
252b5132 9312
718175fa
JK		 9313 switch (bfd_get_format (abfd))
9314 {
9315 default:
9316 return TRUE;
9317
9318 case bfd_core:
9319 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
9320 {
9321 if (! elfcore_grok_netbsd_note (abfd, &in))
9322 return FALSE;
9323 }
67cc5033
MK		 9324 else if (CONST_STRNEQ (in.namedata, "OpenBSD"))
9325 {
9326 if (! elfcore_grok_openbsd_note (abfd, &in))
9327 return FALSE;
9328 }
718175fa
JK		 9329 else if (CONST_STRNEQ (in.namedata, "QNX"))
9330 {
9331 if (! elfcore_grok_nto_note (abfd, &in))
9332 return FALSE;
9333 }
b15fa79e
AM		 9334 else if (CONST_STRNEQ (in.namedata, "SPU/"))
9335 {
9336 if (! elfcore_grok_spu_note (abfd, &in))
9337 return FALSE;
9338 }
718175fa
JK		 9339 else
9340 {
9341 if (! elfcore_grok_note (abfd, &in))
9342 return FALSE;
9343 }
9344 break;
9345
9346 case bfd_object:
9347 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
9348 {
9349 if (! elfobj_grok_gnu_note (abfd, &in))
9350 return FALSE;
9351 }
e21e5835
NC		 9352 else if (in.namesz == sizeof "stapsdt"
9353 && strcmp (in.namedata, "stapsdt") == 0)
9354 {
9355 if (! elfobj_grok_stapsdt_note (abfd, &in))
9356 return FALSE;
9357 }
718175fa 9358 break;
08a40648 9359 }
252b5132
RH		 9360
9361 p = in.descdata + BFD_ALIGN (in.descsz, 4);
9362 }
9363
718175fa
JK		 9364 return TRUE;
9365}
9366
9367static bfd_boolean
9368elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
9369{
9370 char *buf;
9371
9372 if (size <= 0)
9373 return TRUE;
9374
9375 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
9376 return FALSE;
9377
a50b1753 9378 buf = (char *) bfd_malloc (size);
718175fa
JK		 9379 if (buf == NULL)
9380 return FALSE;
9381
9382 if (bfd_bread (buf, size, abfd) != size
9383 || !elf_parse_notes (abfd, buf, size, offset))
9384 {
9385 free (buf);
9386 return FALSE;
9387 }
9388
252b5132 9389 free (buf);
b34976b6 9390 return TRUE;
252b5132 9391}
98d8431c
JB		 9392\f
9393/* Providing external access to the ELF program header table. */
9394
9395/* Return an upper bound on the number of bytes required to store a
9396 copy of ABFD's program header table entries. Return -1 if an error
9397 occurs; bfd_get_error will return an appropriate code. */
c044fabd 9398
98d8431c 9399long
217aa764 9400bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB		 9401{
9402 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9403 {
9404 bfd_set_error (bfd_error_wrong_format);
9405 return -1;
9406 }
9407
936e320b 9408 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB		 9409}
9410
98d8431c
JB		 9411/* Copy ABFD's program header table entries to *PHDRS. The entries
9412 will be stored as an array of Elf_Internal_Phdr structures, as
9413 defined in include/elf/internal.h. To find out how large the
9414 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
9415
9416 Return the number of program header table entries read, or -1 if an
9417 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 9418
98d8431c 9419int
217aa764 9420bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB		 9421{
9422 int num_phdrs;
9423
9424 if (abfd->xvec->flavour != bfd_target_elf_flavour)
9425 {
9426 bfd_set_error (bfd_error_wrong_format);
9427 return -1;
9428 }
9429
9430 num_phdrs = elf_elfheader (abfd)->e_phnum;
c044fabd 9431 memcpy (phdrs, elf_tdata (abfd)->phdr,
98d8431c
JB		 9432 num_phdrs * sizeof (Elf_Internal_Phdr));
9433
9434 return num_phdrs;
9435}
ae4221d7 9436
db6751f2 9437enum elf_reloc_type_class
217aa764 9438_bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ		 9439{
9440 return reloc_class_normal;
9441}
f8df10f4 9442
47d9a591 9443/* For RELA architectures, return the relocation value for a
f8df10f4
JJ		 9444 relocation against a local symbol. */
9445
9446bfd_vma
217aa764
AM		 9447_bfd_elf_rela_local_sym (bfd *abfd,
9448 Elf_Internal_Sym *sym,
8517fae7 9449 asection **psec,
217aa764 9450 Elf_Internal_Rela *rel)
f8df10f4 9451{
8517fae7 9452 asection *sec = *psec;
f8df10f4
JJ		 9453 bfd_vma relocation;
9454
9455 relocation = (sec->output_section->vma
9456 + sec->output_offset
9457 + sym->st_value);
9458 if ((sec->flags & SEC_MERGE)
c629eae0 9459 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
dbaa2011 9460 && sec->sec_info_type == SEC_INFO_TYPE_MERGE)
f8df10f4 9461 {
f8df10f4 9462 rel->r_addend =
8517fae7 9463 _bfd_merged_section_offset (abfd, psec,
65765700 9464 elf_section_data (sec)->sec_info,
753731ee
AM		 9465 sym->st_value + rel->r_addend);
9466 if (sec != *psec)
9467 {
9468 /* If we have changed the section, and our original section is
9469 marked with SEC_EXCLUDE, it means that the original
9470 SEC_MERGE section has been completely subsumed in some
9471 other SEC_MERGE section. In this case, we need to leave
9472 some info around for --emit-relocs. */
9473 if ((sec->flags & SEC_EXCLUDE) != 0)
9474 sec->kept_section = *psec;
9475 sec = *psec;
9476 }
8517fae7
AM		 9477 rel->r_addend -= relocation;
9478 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ		 9479 }
9480 return relocation;
9481}
c629eae0
JJ		 9482
9483bfd_vma
217aa764
AM		 9484_bfd_elf_rel_local_sym (bfd *abfd,
9485 Elf_Internal_Sym *sym,
9486 asection **psec,
9487 bfd_vma addend)
47d9a591 9488{
c629eae0
JJ		 9489 asection *sec = *psec;
9490
dbaa2011 9491 if (sec->sec_info_type != SEC_INFO_TYPE_MERGE)
c629eae0
JJ		 9492 return sym->st_value + addend;
9493
9494 return _bfd_merged_section_offset (abfd, psec,
65765700 9495 elf_section_data (sec)->sec_info,
753731ee 9496 sym->st_value + addend);
c629eae0
JJ		 9497}
9498
9499bfd_vma
217aa764 9500_bfd_elf_section_offset (bfd *abfd,
92e4ec35 9501 struct bfd_link_info *info,
217aa764
AM		 9502 asection *sec,
9503 bfd_vma offset)
c629eae0 9504{
68bfbfcc 9505 switch (sec->sec_info_type)
65765700 9506 {
dbaa2011 9507 case SEC_INFO_TYPE_STABS:
eea6121a
AM		 9508 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
9509 offset);
dbaa2011 9510 case SEC_INFO_TYPE_EH_FRAME:
92e4ec35 9511 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
65765700 9512 default:
310fd250
L		 9513 if ((sec->flags & SEC_ELF_REVERSE_COPY) != 0)
9514 {
9515 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9516 bfd_size_type address_size = bed->s->arch_size / 8;
9517 offset = sec->size - offset - address_size;
9518 }
65765700
JJ		 9519 return offset;
9520 }
c629eae0 9521}
3333a7c3
RM		 9522\f
9523/* Create a new BFD as if by bfd_openr. Rather than opening a file,
9524 reconstruct an ELF file by reading the segments out of remote memory
9525 based on the ELF file header at EHDR_VMA and the ELF program headers it
9526 points to. If not null, *LOADBASEP is filled in with the difference
9527 between the VMAs from which the segments were read, and the VMAs the
9528 file headers (and hence BFD's idea of each section's VMA) put them at.
9529
9530 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
9531 remote memory at target address VMA into the local buffer at MYADDR; it
9532 should return zero on success or an `errno' code on failure. TEMPL must
9533 be a BFD for an ELF target with the word size and byte order found in
9534 the remote memory. */
9535
9536bfd *
217aa764
AM		 9537bfd_elf_bfd_from_remote_memory
9538 (bfd *templ,
9539 bfd_vma ehdr_vma,
9540 bfd_vma *loadbasep,
f075ee0c 9541 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
3333a7c3
RM		 9542{
9543 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
9544 (templ, ehdr_vma, loadbasep, target_read_memory);
9545}
4c45e5c9
JJ		 9546\f
9547long
c9727e01
AM		 9548_bfd_elf_get_synthetic_symtab (bfd *abfd,
9549 long symcount ATTRIBUTE_UNUSED,
9550 asymbol **syms ATTRIBUTE_UNUSED,
8615f3f2 9551 long dynsymcount,
c9727e01
AM		 9552 asymbol **dynsyms,
9553 asymbol **ret)
4c45e5c9
JJ		 9554{
9555 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
9556 asection *relplt;
9557 asymbol *s;
9558 const char *relplt_name;
9559 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
9560 arelent *p;
9561 long count, i, n;
9562 size_t size;
9563 Elf_Internal_Shdr *hdr;
9564 char *names;
9565 asection *plt;
9566
8615f3f2
AM		 9567 *ret = NULL;
9568
90e3cdf2
JJ		 9569 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
9570 return 0;
9571
8615f3f2
AM		 9572 if (dynsymcount <= 0)
9573 return 0;
9574
4c45e5c9
JJ		 9575 if (!bed->plt_sym_val)
9576 return 0;
9577
9578 relplt_name = bed->relplt_name;
9579 if (relplt_name == NULL)
d35fd659 9580 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
4c45e5c9
JJ		 9581 relplt = bfd_get_section_by_name (abfd, relplt_name);
9582 if (relplt == NULL)
9583 return 0;
9584
9585 hdr = &elf_section_data (relplt)->this_hdr;
9586 if (hdr->sh_link != elf_dynsymtab (abfd)
9587 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
9588 return 0;
9589
9590 plt = bfd_get_section_by_name (abfd, ".plt");
9591 if (plt == NULL)
9592 return 0;
9593
9594 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 9595 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ		 9596 return -1;
9597
eea6121a 9598 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ		 9599 size = count * sizeof (asymbol);
9600 p = relplt->relocation;
cb53bf42 9601 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
041de40d
AM		 9602 {
9603 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
9604 if (p->addend != 0)
9605 {
9606#ifdef BFD64
9607 size += sizeof ("+0x") - 1 + 8 + 8 * (bed->s->elfclass == ELFCLASS64);
9608#else
9609 size += sizeof ("+0x") - 1 + 8;
9610#endif
9611 }
9612 }
4c45e5c9 9613
a50b1753 9614 s = *ret = (asymbol *) bfd_malloc (size);
4c45e5c9
JJ		 9615 if (s == NULL)
9616 return -1;
9617
9618 names = (char *) (s + count);
9619 p = relplt->relocation;
9620 n = 0;
cb53bf42 9621 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
4c45e5c9
JJ		 9622 {
9623 size_t len;
9624 bfd_vma addr;
9625
9626 addr = bed->plt_sym_val (i, plt, p);
9627 if (addr == (bfd_vma) -1)
9628 continue;
9629
9630 *s = **p->sym_ptr_ptr;
65a7a66f
AM		 9631 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
9632 we are defining a symbol, ensure one of them is set. */
9633 if ((s->flags & BSF_LOCAL) == 0)
9634 s->flags |= BSF_GLOBAL;
6ba2a415 9635 s->flags |= BSF_SYNTHETIC;
4c45e5c9
JJ		 9636 s->section = plt;
9637 s->value = addr - plt->vma;
9638 s->name = names;
8f39ba8e 9639 s->udata.p = NULL;
4c45e5c9
JJ		 9640 len = strlen ((*p->sym_ptr_ptr)->name);
9641 memcpy (names, (*p->sym_ptr_ptr)->name, len);
9642 names += len;
041de40d
AM		 9643 if (p->addend != 0)
9644 {
1d770845 9645 char buf[30], *a;
d324f6d6 9646
041de40d
AM		 9647 memcpy (names, "+0x", sizeof ("+0x") - 1);
9648 names += sizeof ("+0x") - 1;
1d770845
L		 9649 bfd_sprintf_vma (abfd, buf, p->addend);
9650 for (a = buf; *a == '0'; ++a)
9651 ;
9652 len = strlen (a);
9653 memcpy (names, a, len);
9654 names += len;
041de40d 9655 }
4c45e5c9
JJ		 9656 memcpy (names, "@plt", sizeof ("@plt"));
9657 names += sizeof ("@plt");
8f39ba8e 9658 ++s, ++n;
4c45e5c9
JJ		 9659 }
9660
9661 return n;
9662}
3d7f7666 9663
3b22753a
L		 9664/* It is only used by x86-64 so far. */
9665asection _bfd_elf_large_com_section
9666 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
f592407e 9667 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
ecca9871 9668
d1036acb
L		 9669void
9670_bfd_elf_set_osabi (bfd * abfd,
9671 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
9672{
9673 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
9674
9675 i_ehdrp = elf_elfheader (abfd);
9676
9677 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
d8045f23
NC		 9678
9679 /* To make things simpler for the loader on Linux systems we set the
9c55345c 9680 osabi field to ELFOSABI_GNU if the binary contains symbols of
f64b2e8d 9681 the STT_GNU_IFUNC type or STB_GNU_UNIQUE binding. */
d8045f23 9682 if (i_ehdrp->e_ident[EI_OSABI] == ELFOSABI_NONE
f64b2e8d 9683 && elf_tdata (abfd)->has_gnu_symbols)
9c55345c 9684 i_ehdrp->e_ident[EI_OSABI] = ELFOSABI_GNU;
d1036acb 9685}
fcb93ecf
PB		 9686
9687
9688/* Return TRUE for ELF symbol types that represent functions.
9689 This is the default version of this function, which is sufficient for
d8045f23 9690 most targets. It returns true if TYPE is STT_FUNC or STT_GNU_IFUNC. */
fcb93ecf
PB		 9691
9692bfd_boolean
9693_bfd_elf_is_function_type (unsigned int type)
9694{
d8045f23
NC		 9695 return (type == STT_FUNC
9696 || type == STT_GNU_IFUNC);
fcb93ecf 9697}
9f296da3
AM		 9698
9699/* Return TRUE iff the ELF symbol SYM might be a function. Set *CODE_SEC
9700 and *CODE_OFF to the function's entry point. */
9701
9702bfd_boolean
ff9e0f5b 9703_bfd_elf_maybe_function_sym (const asymbol *sym,
9f296da3
AM		 9704 asection **code_sec, bfd_vma *code_off)
9705{
ff9e0f5b
AM		 9706 if ((sym->flags & (BSF_SECTION_SYM | BSF_FILE | BSF_OBJECT
9707 | BSF_THREAD_LOCAL | BSF_RELC | BSF_SRELC)) != 0)
9708 return FALSE;
9709
9710 *code_sec = sym->section;
9711 *code_off = sym->value;
9712 return TRUE;
9f296da3 9713}
GDB Binutils - Deliverables
This page took 1.415732 seconds and 4 git commands to generate.