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