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