projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
2009-02-25 Hui Zhu <teawater@gmail.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
ec338859
AM		 1924/* Return the section for the local symbol specified by ABFD, R_SYMNDX.
1925 Return SEC for sections that have no elf section, and NULL on error. */
1926
1927asection *
217aa764
AM		 1928bfd_section_from_r_symndx (bfd *abfd,
1929 struct sym_sec_cache *cache,
1930 asection *sec,
1931 unsigned long r_symndx)
ec338859 1932{
ec338859 1933 unsigned int ent = r_symndx % LOCAL_SYM_CACHE_SIZE;
a5d1b3b5 1934 asection *s;
ec338859 1935
a5d1b3b5
AM		 1936 if (cache->abfd != abfd || cache->indx[ent] != r_symndx)
1937 {
1938 Elf_Internal_Shdr *symtab_hdr;
1939 unsigned char esym[sizeof (Elf64_External_Sym)];
1940 Elf_External_Sym_Shndx eshndx;
1941 Elf_Internal_Sym isym;
ec338859 1942
a5d1b3b5
AM		 1943 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1944 if (bfd_elf_get_elf_syms (abfd, symtab_hdr, 1, r_symndx,
1945 &isym, esym, &eshndx) == NULL)
1946 return NULL;
9ad5cbcf 1947
a5d1b3b5
AM		 1948 if (cache->abfd != abfd)
1949 {
1950 memset (cache->indx, -1, sizeof (cache->indx));
1951 cache->abfd = abfd;
1952 }
1953 cache->indx[ent] = r_symndx;
1954 cache->shndx[ent] = isym.st_shndx;
ec338859 1955 }
a5d1b3b5
AM		 1956
1957 s = bfd_section_from_elf_index (abfd, cache->shndx[ent]);
1958 if (s != NULL)
1959 return s;
1960
1961 return sec;
ec338859
AM		 1962}
1963
252b5132
RH		 1964/* Given an ELF section number, retrieve the corresponding BFD
1965 section. */
1966
1967asection *
217aa764 1968bfd_section_from_elf_index (bfd *abfd, unsigned int index)
252b5132 1969{
9ad5cbcf 1970 if (index >= elf_numsections (abfd))
252b5132
RH		 1971 return NULL;
1972 return elf_elfsections (abfd)[index]->bfd_section;
1973}
1974
b35d266b 1975static const struct bfd_elf_special_section special_sections_b[] =
2f89ff8d 1976{
0112cd26
NC		 1977 { STRING_COMMA_LEN (".bss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
1978 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 1979};
1980
b35d266b 1981static const struct bfd_elf_special_section special_sections_c[] =
7f4d3958 1982{
0112cd26
NC		 1983 { STRING_COMMA_LEN (".comment"), 0, SHT_PROGBITS, 0 },
1984 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 1985};
1986
b35d266b 1987static const struct bfd_elf_special_section special_sections_d[] =
7f4d3958 1988{
0112cd26
NC		 1989 { STRING_COMMA_LEN (".data"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1990 { STRING_COMMA_LEN (".data1"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
1991 { STRING_COMMA_LEN (".debug"), 0, SHT_PROGBITS, 0 },
1992 { STRING_COMMA_LEN (".debug_line"), 0, SHT_PROGBITS, 0 },
1993 { STRING_COMMA_LEN (".debug_info"), 0, SHT_PROGBITS, 0 },
1994 { STRING_COMMA_LEN (".debug_abbrev"), 0, SHT_PROGBITS, 0 },
1995 { STRING_COMMA_LEN (".debug_aranges"), 0, SHT_PROGBITS, 0 },
1996 { STRING_COMMA_LEN (".dynamic"), 0, SHT_DYNAMIC, SHF_ALLOC },
1997 { STRING_COMMA_LEN (".dynstr"), 0, SHT_STRTAB, SHF_ALLOC },
1998 { STRING_COMMA_LEN (".dynsym"), 0, SHT_DYNSYM, SHF_ALLOC },
1999 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2000};
2001
b35d266b 2002static const struct bfd_elf_special_section special_sections_f[] =
7f4d3958 2003{
0112cd26
NC		 2004 { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2005 { STRING_COMMA_LEN (".fini_array"), 0, SHT_FINI_ARRAY, SHF_ALLOC + SHF_WRITE },
2006 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2007};
2008
b35d266b 2009static const struct bfd_elf_special_section special_sections_g[] =
7f4d3958 2010{
0112cd26
NC		 2011 { STRING_COMMA_LEN (".gnu.linkonce.b"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE },
2012 { STRING_COMMA_LEN (".got"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
2013 { STRING_COMMA_LEN (".gnu.version"), 0, SHT_GNU_versym, 0 },
2014 { STRING_COMMA_LEN (".gnu.version_d"), 0, SHT_GNU_verdef, 0 },
2015 { STRING_COMMA_LEN (".gnu.version_r"), 0, SHT_GNU_verneed, 0 },
2016 { STRING_COMMA_LEN (".gnu.liblist"), 0, SHT_GNU_LIBLIST, SHF_ALLOC },
2017 { STRING_COMMA_LEN (".gnu.conflict"), 0, SHT_RELA, SHF_ALLOC },
2018 { STRING_COMMA_LEN (".gnu.hash"), 0, SHT_GNU_HASH, SHF_ALLOC },
2019 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2020};
2021
b35d266b 2022static const struct bfd_elf_special_section special_sections_h[] =
7f4d3958 2023{
0112cd26
NC		 2024 { STRING_COMMA_LEN (".hash"), 0, SHT_HASH, SHF_ALLOC },
2025 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2026};
2027
b35d266b 2028static const struct bfd_elf_special_section special_sections_i[] =
7f4d3958 2029{
0112cd26
NC		 2030 { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2031 { STRING_COMMA_LEN (".init_array"), 0, SHT_INIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2032 { STRING_COMMA_LEN (".interp"), 0, SHT_PROGBITS, 0 },
2033 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2034};
2035
b35d266b 2036static const struct bfd_elf_special_section special_sections_l[] =
7f4d3958 2037{
0112cd26
NC		 2038 { STRING_COMMA_LEN (".line"), 0, SHT_PROGBITS, 0 },
2039 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2040};
2041
b35d266b 2042static const struct bfd_elf_special_section special_sections_n[] =
7f4d3958 2043{
0112cd26
NC		 2044 { STRING_COMMA_LEN (".note.GNU-stack"), 0, SHT_PROGBITS, 0 },
2045 { STRING_COMMA_LEN (".note"), -1, SHT_NOTE, 0 },
2046 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2047};
2048
b35d266b 2049static const struct bfd_elf_special_section special_sections_p[] =
7f4d3958 2050{
0112cd26
NC		 2051 { STRING_COMMA_LEN (".preinit_array"), 0, SHT_PREINIT_ARRAY, SHF_ALLOC + SHF_WRITE },
2052 { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2053 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2054};
2055
b35d266b 2056static const struct bfd_elf_special_section special_sections_r[] =
7f4d3958 2057{
0112cd26
NC		 2058 { STRING_COMMA_LEN (".rodata"), -2, SHT_PROGBITS, SHF_ALLOC },
2059 { STRING_COMMA_LEN (".rodata1"), 0, SHT_PROGBITS, SHF_ALLOC },
2060 { STRING_COMMA_LEN (".rela"), -1, SHT_RELA, 0 },
2061 { STRING_COMMA_LEN (".rel"), -1, SHT_REL, 0 },
2062 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2063};
2064
b35d266b 2065static const struct bfd_elf_special_section special_sections_s[] =
7f4d3958 2066{
0112cd26
NC		 2067 { STRING_COMMA_LEN (".shstrtab"), 0, SHT_STRTAB, 0 },
2068 { STRING_COMMA_LEN (".strtab"), 0, SHT_STRTAB, 0 },
2069 { STRING_COMMA_LEN (".symtab"), 0, SHT_SYMTAB, 0 },
60ff4dc4
HPN		 2070 /* See struct bfd_elf_special_section declaration for the semantics of
2071 this special case where .prefix_length != strlen (.prefix). */
2072 { ".stabstr", 5, 3, SHT_STRTAB, 0 },
0112cd26 2073 { NULL, 0, 0, 0, 0 }
2f89ff8d
L		 2074};
2075
b35d266b 2076static const struct bfd_elf_special_section special_sections_t[] =
7f4d3958 2077{
0112cd26
NC		 2078 { STRING_COMMA_LEN (".text"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
2079 { STRING_COMMA_LEN (".tbss"), -2, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2080 { STRING_COMMA_LEN (".tdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_TLS },
2081 { NULL, 0, 0, 0, 0 }
7f4d3958
L		 2082};
2083
1b315056
CS		 2084static const struct bfd_elf_special_section special_sections_z[] =
2085{
2086 { STRING_COMMA_LEN (".zdebug_line"), 0, SHT_PROGBITS, 0 },
2087 { STRING_COMMA_LEN (".zdebug_info"), 0, SHT_PROGBITS, 0 },
2088 { STRING_COMMA_LEN (".zdebug_abbrev"), 0, SHT_PROGBITS, 0 },
2089 { STRING_COMMA_LEN (".zdebug_aranges"), 0, SHT_PROGBITS, 0 },
2090 { NULL, 0, 0, 0, 0 }
2091};
2092
b35d266b 2093static const struct bfd_elf_special_section *special_sections[] =
7f4d3958 2094{
7f4d3958 2095 special_sections_b, /* 'b' */
98ece1b3 2096 special_sections_c, /* 'c' */
7f4d3958
L		 2097 special_sections_d, /* 'd' */
2098 NULL, /* 'e' */
2099 special_sections_f, /* 'f' */
2100 special_sections_g, /* 'g' */
2101 special_sections_h, /* 'h' */
2102 special_sections_i, /* 'i' */
2103 NULL, /* 'j' */
2104 NULL, /* 'k' */
2105 special_sections_l, /* 'l' */
2106 NULL, /* 'm' */
2107 special_sections_n, /* 'n' */
2108 NULL, /* 'o' */
2109 special_sections_p, /* 'p' */
2110 NULL, /* 'q' */
2111 special_sections_r, /* 'r' */
2112 special_sections_s, /* 's' */
2113 special_sections_t, /* 't' */
1b315056
CS		 2114 NULL, /* 'u' */
2115 NULL, /* 'v' */
2116 NULL, /* 'w' */
2117 NULL, /* 'x' */
2118 NULL, /* 'y' */
2119 special_sections_z /* 'z' */
7f4d3958
L		 2120};
2121
551b43fd
AM		 2122const struct bfd_elf_special_section *
2123_bfd_elf_get_special_section (const char *name,
2124 const struct bfd_elf_special_section *spec,
2125 unsigned int rela)
2f89ff8d
L		 2126{
2127 int i;
7f4d3958 2128 int len;
7f4d3958 2129
551b43fd 2130 len = strlen (name);
7f4d3958 2131
551b43fd 2132 for (i = 0; spec[i].prefix != NULL; i++)
7dcb9820
AM		 2133 {
2134 int suffix_len;
551b43fd 2135 int prefix_len = spec[i].prefix_length;
7dcb9820
AM		 2136
2137 if (len < prefix_len)
2138 continue;
551b43fd 2139 if (memcmp (name, spec[i].prefix, prefix_len) != 0)
7dcb9820
AM		 2140 continue;
2141
551b43fd 2142 suffix_len = spec[i].suffix_length;
7dcb9820
AM		 2143 if (suffix_len <= 0)
2144 {
2145 if (name[prefix_len] != 0)
2146 {
2147 if (suffix_len == 0)
2148 continue;
2149 if (name[prefix_len] != '.'
2150 && (suffix_len == -2
551b43fd 2151 || (rela && spec[i].type == SHT_REL)))
7dcb9820
AM		 2152 continue;
2153 }
2154 }
2155 else
2156 {
2157 if (len < prefix_len + suffix_len)
2158 continue;
2159 if (memcmp (name + len - suffix_len,
551b43fd 2160 spec[i].prefix + prefix_len,
7dcb9820
AM		 2161 suffix_len) != 0)
2162 continue;
2163 }
551b43fd 2164 return &spec[i];
7dcb9820 2165 }
2f89ff8d
L		 2166
2167 return NULL;
2168}
2169
7dcb9820 2170const struct bfd_elf_special_section *
29ef7005 2171_bfd_elf_get_sec_type_attr (bfd *abfd, asection *sec)
2f89ff8d 2172{
551b43fd
AM		 2173 int i;
2174 const struct bfd_elf_special_section *spec;
29ef7005 2175 const struct elf_backend_data *bed;
2f89ff8d
L		 2176
2177 /* See if this is one of the special sections. */
551b43fd
AM		 2178 if (sec->name == NULL)
2179 return NULL;
2f89ff8d 2180
29ef7005
L		 2181 bed = get_elf_backend_data (abfd);
2182 spec = bed->special_sections;
2183 if (spec)
2184 {
2185 spec = _bfd_elf_get_special_section (sec->name,
2186 bed->special_sections,
2187 sec->use_rela_p);
2188 if (spec != NULL)
2189 return spec;
2190 }
2191
551b43fd
AM		 2192 if (sec->name[0] != '.')
2193 return NULL;
2f89ff8d 2194
551b43fd 2195 i = sec->name[1] - 'b';
1b315056 2196 if (i < 0 || i > 'z' - 'b')
551b43fd
AM		 2197 return NULL;
2198
2199 spec = special_sections[i];
2f89ff8d 2200
551b43fd
AM		 2201 if (spec == NULL)
2202 return NULL;
2203
2204 return _bfd_elf_get_special_section (sec->name, spec, sec->use_rela_p);
2f89ff8d
L		 2205}
2206
b34976b6 2207bfd_boolean
217aa764 2208_bfd_elf_new_section_hook (bfd *abfd, asection *sec)
252b5132
RH		 2209{
2210 struct bfd_elf_section_data *sdata;
551b43fd 2211 const struct elf_backend_data *bed;
7dcb9820 2212 const struct bfd_elf_special_section *ssect;
252b5132 2213
f0abc2a1
AM		 2214 sdata = (struct bfd_elf_section_data *) sec->used_by_bfd;
2215 if (sdata == NULL)
2216 {
217aa764 2217 sdata = bfd_zalloc (abfd, sizeof (*sdata));
f0abc2a1
AM		 2218 if (sdata == NULL)
2219 return FALSE;
217aa764 2220 sec->used_by_bfd = sdata;
f0abc2a1 2221 }
bf572ba0 2222
551b43fd
AM		 2223 /* Indicate whether or not this section should use RELA relocations. */
2224 bed = get_elf_backend_data (abfd);
2225 sec->use_rela_p = bed->default_use_rela_p;
2226
e843e0f8
L		 2227 /* When we read a file, we don't need to set ELF section type and
2228 flags. They will be overridden in _bfd_elf_make_section_from_shdr
2229 anyway. We will set ELF section type and flags for all linker
2230 created sections. If user specifies BFD section flags, we will
2231 set ELF section type and flags based on BFD section flags in
2232 elf_fake_sections. */
2233 if ((!sec->flags && abfd->direction != read_direction)
3496cb2a 2234 || (sec->flags & SEC_LINKER_CREATED) != 0)
2f89ff8d 2235 {
551b43fd 2236 ssect = (*bed->get_sec_type_attr) (abfd, sec);
a31501e9
L		 2237 if (ssect != NULL)
2238 {
2239 elf_section_type (sec) = ssect->type;
2240 elf_section_flags (sec) = ssect->attr;
2241 }
2f89ff8d
L		 2242 }
2243
f592407e 2244 return _bfd_generic_new_section_hook (abfd, sec);
252b5132
RH		 2245}
2246
2247/* Create a new bfd section from an ELF program header.
2248
2249 Since program segments have no names, we generate a synthetic name
2250 of the form segment<NUM>, where NUM is generally the index in the
2251 program header table. For segments that are split (see below) we
2252 generate the names segment<NUM>a and segment<NUM>b.
2253
2254 Note that some program segments may have a file size that is different than
2255 (less than) the memory size. All this means is that at execution the
2256 system must allocate the amount of memory specified by the memory size,
2257 but only initialize it with the first "file size" bytes read from the
2258 file. This would occur for example, with program segments consisting
2259 of combined data+bss.
2260
2261 To handle the above situation, this routine generates TWO bfd sections
2262 for the single program segment. The first has the length specified by
2263 the file size of the segment, and the second has the length specified
2264 by the difference between the two sizes. In effect, the segment is split
d5191d0c 2265 into its initialized and uninitialized parts.
252b5132
RH		 2266
2267 */
2268
b34976b6 2269bfd_boolean
217aa764
AM		 2270_bfd_elf_make_section_from_phdr (bfd *abfd,
2271 Elf_Internal_Phdr *hdr,
2272 int index,
2273 const char *typename)
252b5132
RH		 2274{
2275 asection *newsect;
2276 char *name;
2277 char namebuf[64];
d4c88bbb 2278 size_t len;
252b5132
RH		 2279 int split;
2280
2281 split = ((hdr->p_memsz > 0)
2282 && (hdr->p_filesz > 0)
2283 && (hdr->p_memsz > hdr->p_filesz));
d5191d0c
AM		 2284
2285 if (hdr->p_filesz > 0)
252b5132 2286 {
d5191d0c
AM		 2287 sprintf (namebuf, "%s%d%s", typename, index, split ? "a" : "");
2288 len = strlen (namebuf) + 1;
2289 name = bfd_alloc (abfd, len);
2290 if (!name)
2291 return FALSE;
2292 memcpy (name, namebuf, len);
2293 newsect = bfd_make_section (abfd, name);
2294 if (newsect == NULL)
2295 return FALSE;
2296 newsect->vma = hdr->p_vaddr;
2297 newsect->lma = hdr->p_paddr;
2298 newsect->size = hdr->p_filesz;
2299 newsect->filepos = hdr->p_offset;
2300 newsect->flags |= SEC_HAS_CONTENTS;
2301 newsect->alignment_power = bfd_log2 (hdr->p_align);
2302 if (hdr->p_type == PT_LOAD)
252b5132 2303 {
d5191d0c
AM		 2304 newsect->flags |= SEC_ALLOC;
2305 newsect->flags |= SEC_LOAD;
2306 if (hdr->p_flags & PF_X)
2307 {
2308 /* FIXME: all we known is that it has execute PERMISSION,
2309 may be data. */
2310 newsect->flags |= SEC_CODE;
2311 }
2312 }
2313 if (!(hdr->p_flags & PF_W))
2314 {
2315 newsect->flags |= SEC_READONLY;
252b5132 2316 }
252b5132
RH		 2317 }
2318
d5191d0c 2319 if (hdr->p_memsz > hdr->p_filesz)
252b5132 2320 {
d5191d0c
AM		 2321 bfd_vma align;
2322
2323 sprintf (namebuf, "%s%d%s", typename, index, split ? "b" : "");
d4c88bbb 2324 len = strlen (namebuf) + 1;
217aa764 2325 name = bfd_alloc (abfd, len);
252b5132 2326 if (!name)
b34976b6 2327 return FALSE;
d4c88bbb 2328 memcpy (name, namebuf, len);
252b5132
RH		 2329 newsect = bfd_make_section (abfd, name);
2330 if (newsect == NULL)
b34976b6 2331 return FALSE;
252b5132
RH		 2332 newsect->vma = hdr->p_vaddr + hdr->p_filesz;
2333 newsect->lma = hdr->p_paddr + hdr->p_filesz;
eea6121a 2334 newsect->size = hdr->p_memsz - hdr->p_filesz;
d5191d0c
AM		 2335 newsect->filepos = hdr->p_offset + hdr->p_filesz;
2336 align = newsect->vma & -newsect->vma;
2337 if (align == 0 || align > hdr->p_align)
2338 align = hdr->p_align;
2339 newsect->alignment_power = bfd_log2 (align);
252b5132
RH		 2340 if (hdr->p_type == PT_LOAD)
2341 {
d5191d0c
AM		 2342 /* Hack for gdb. Segments that have not been modified do
2343 not have their contents written to a core file, on the
2344 assumption that a debugger can find the contents in the
2345 executable. We flag this case by setting the fake
2346 section size to zero. Note that "real" bss sections will
2347 always have their contents dumped to the core file. */
2348 if (bfd_get_format (abfd) == bfd_core)
2349 newsect->size = 0;
252b5132
RH		 2350 newsect->flags |= SEC_ALLOC;
2351 if (hdr->p_flags & PF_X)
2352 newsect->flags |= SEC_CODE;
2353 }
2354 if (!(hdr->p_flags & PF_W))
2355 newsect->flags |= SEC_READONLY;
2356 }
2357
b34976b6 2358 return TRUE;
252b5132
RH		 2359}
2360
b34976b6 2361bfd_boolean
217aa764 2362bfd_section_from_phdr (bfd *abfd, Elf_Internal_Phdr *hdr, int index)
20cfcaae 2363{
9c5bfbb7 2364 const struct elf_backend_data *bed;
20cfcaae
NC		 2365
2366 switch (hdr->p_type)
2367 {
2368 case PT_NULL:
2369 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "null");
2370
2371 case PT_LOAD:
2372 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "load");
2373
2374 case PT_DYNAMIC:
2375 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "dynamic");
2376
2377 case PT_INTERP:
2378 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "interp");
2379
2380 case PT_NOTE:
2381 if (! _bfd_elf_make_section_from_phdr (abfd, hdr, index, "note"))
b34976b6 2382 return FALSE;
718175fa 2383 if (! elf_read_notes (abfd, hdr->p_offset, hdr->p_filesz))
b34976b6
AM		 2384 return FALSE;
2385 return TRUE;
20cfcaae
NC		 2386
2387 case PT_SHLIB:
2388 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "shlib");
2389
2390 case PT_PHDR:
2391 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "phdr");
2392
811072d8
RM		 2393 case PT_GNU_EH_FRAME:
2394 return _bfd_elf_make_section_from_phdr (abfd, hdr, index,
2395 "eh_frame_hdr");
2396
2b05f1b7
L		 2397 case PT_GNU_STACK:
2398 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "stack");
9ee5e499 2399
8c37241b
JJ		 2400 case PT_GNU_RELRO:
2401 return _bfd_elf_make_section_from_phdr (abfd, hdr, index, "relro");
2402
20cfcaae 2403 default:
8c1acd09 2404 /* Check for any processor-specific program segment types. */
20cfcaae 2405 bed = get_elf_backend_data (abfd);
d27f5fa1 2406 return bed->elf_backend_section_from_phdr (abfd, hdr, index, "proc");
20cfcaae
NC		 2407 }
2408}
2409
23bc299b 2410/* Initialize REL_HDR, the section-header for new section, containing
b34976b6 2411 relocations against ASECT. If USE_RELA_P is TRUE, we use RELA
23bc299b
MM		 2412 relocations; otherwise, we use REL relocations. */
2413
b34976b6 2414bfd_boolean
217aa764
AM		 2415_bfd_elf_init_reloc_shdr (bfd *abfd,
2416 Elf_Internal_Shdr *rel_hdr,
2417 asection *asect,
2418 bfd_boolean use_rela_p)
23bc299b
MM		 2419{
2420 char *name;
9c5bfbb7 2421 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
dc810e39 2422 bfd_size_type amt = sizeof ".rela" + strlen (asect->name);
23bc299b 2423
dc810e39 2424 name = bfd_alloc (abfd, amt);
23bc299b 2425 if (name == NULL)
b34976b6 2426 return FALSE;
23bc299b
MM		 2427 sprintf (name, "%s%s", use_rela_p ? ".rela" : ".rel", asect->name);
2428 rel_hdr->sh_name =
2b0f7ef9 2429 (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd), name,
b34976b6 2430 FALSE);
23bc299b 2431 if (rel_hdr->sh_name == (unsigned int) -1)
b34976b6 2432 return FALSE;
23bc299b
MM		 2433 rel_hdr->sh_type = use_rela_p ? SHT_RELA : SHT_REL;
2434 rel_hdr->sh_entsize = (use_rela_p
2435 ? bed->s->sizeof_rela
2436 : bed->s->sizeof_rel);
72de5009 2437 rel_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
23bc299b
MM		 2438 rel_hdr->sh_flags = 0;
2439 rel_hdr->sh_addr = 0;
2440 rel_hdr->sh_size = 0;
2441 rel_hdr->sh_offset = 0;
2442
b34976b6 2443 return TRUE;
23bc299b
MM		 2444}
2445
252b5132
RH		 2446/* Set up an ELF internal section header for a section. */
2447
252b5132 2448static void
217aa764 2449elf_fake_sections (bfd *abfd, asection *asect, void *failedptrarg)
252b5132 2450{
9c5bfbb7 2451 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 2452 bfd_boolean *failedptr = failedptrarg;
252b5132 2453 Elf_Internal_Shdr *this_hdr;
0414f35b 2454 unsigned int sh_type;
252b5132
RH		 2455
2456 if (*failedptr)
2457 {
2458 /* We already failed; just get out of the bfd_map_over_sections
08a40648 2459 loop. */
252b5132
RH		 2460 return;
2461 }
2462
2463 this_hdr = &elf_section_data (asect)->this_hdr;
2464
e57b5356
AM		 2465 this_hdr->sh_name = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
2466 asect->name, FALSE);
2467 if (this_hdr->sh_name == (unsigned int) -1)
252b5132 2468 {
b34976b6 2469 *failedptr = TRUE;
252b5132
RH		 2470 return;
2471 }
2472
a4d8e49b 2473 /* Don't clear sh_flags. Assembler may set additional bits. */
252b5132
RH		 2474
2475 if ((asect->flags & SEC_ALLOC) != 0
2476 || asect->user_set_vma)
2477 this_hdr->sh_addr = asect->vma;
2478 else
2479 this_hdr->sh_addr = 0;
2480
2481 this_hdr->sh_offset = 0;
eea6121a 2482 this_hdr->sh_size = asect->size;
252b5132 2483 this_hdr->sh_link = 0;
72de5009 2484 this_hdr->sh_addralign = (bfd_vma) 1 << asect->alignment_power;
252b5132
RH		 2485 /* The sh_entsize and sh_info fields may have been set already by
2486 copy_private_section_data. */
2487
2488 this_hdr->bfd_section = asect;
2489 this_hdr->contents = NULL;
2490
3cddba1e
L		 2491 /* If the section type is unspecified, we set it based on
2492 asect->flags. */
98ece1b3
AM		 2493 if ((asect->flags & SEC_GROUP) != 0)
2494 sh_type = SHT_GROUP;
2495 else if ((asect->flags & SEC_ALLOC) != 0
2496 && (((asect->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
2497 || (asect->flags & SEC_NEVER_LOAD) != 0))
2498 sh_type = SHT_NOBITS;
2499 else
2500 sh_type = SHT_PROGBITS;
2501
3cddba1e 2502 if (this_hdr->sh_type == SHT_NULL)
98ece1b3
AM		 2503 this_hdr->sh_type = sh_type;
2504 else if (this_hdr->sh_type == SHT_NOBITS
2505 && sh_type == SHT_PROGBITS
2506 && (asect->flags & SEC_ALLOC) != 0)
3cddba1e 2507 {
98ece1b3
AM		 2508 /* Warn if we are changing a NOBITS section to PROGBITS, but
2509 allow the link to proceed. This can happen when users link
2510 non-bss input sections to bss output sections, or emit data
2511 to a bss output section via a linker script. */
2512 (*_bfd_error_handler)
58f0869b 2513 (_("warning: section `%A' type changed to PROGBITS"), asect);
98ece1b3 2514 this_hdr->sh_type = sh_type;
3cddba1e
L		 2515 }
2516
2f89ff8d 2517 switch (this_hdr->sh_type)
252b5132 2518 {
2f89ff8d 2519 default:
2f89ff8d
L		 2520 break;
2521
2522 case SHT_STRTAB:
2523 case SHT_INIT_ARRAY:
2524 case SHT_FINI_ARRAY:
2525 case SHT_PREINIT_ARRAY:
2526 case SHT_NOTE:
2527 case SHT_NOBITS:
2528 case SHT_PROGBITS:
2529 break;
2530
2531 case SHT_HASH:
c7ac6ff8 2532 this_hdr->sh_entsize = bed->s->sizeof_hash_entry;
2f89ff8d 2533 break;
5de3bf90 2534
2f89ff8d 2535 case SHT_DYNSYM:
252b5132 2536 this_hdr->sh_entsize = bed->s->sizeof_sym;
2f89ff8d
L		 2537 break;
2538
2539 case SHT_DYNAMIC:
252b5132 2540 this_hdr->sh_entsize = bed->s->sizeof_dyn;
2f89ff8d
L		 2541 break;
2542
2543 case SHT_RELA:
2544 if (get_elf_backend_data (abfd)->may_use_rela_p)
2545 this_hdr->sh_entsize = bed->s->sizeof_rela;
2546 break;
2547
2548 case SHT_REL:
2549 if (get_elf_backend_data (abfd)->may_use_rel_p)
2550 this_hdr->sh_entsize = bed->s->sizeof_rel;
2551 break;
2552
2553 case SHT_GNU_versym:
252b5132 2554 this_hdr->sh_entsize = sizeof (Elf_External_Versym);
2f89ff8d
L		 2555 break;
2556
2557 case SHT_GNU_verdef:
252b5132
RH		 2558 this_hdr->sh_entsize = 0;
2559 /* objcopy or strip will copy over sh_info, but may not set
08a40648
AM		 2560 cverdefs. The linker will set cverdefs, but sh_info will be
2561 zero. */
252b5132
RH		 2562 if (this_hdr->sh_info == 0)
2563 this_hdr->sh_info = elf_tdata (abfd)->cverdefs;
2564 else
2565 BFD_ASSERT (elf_tdata (abfd)->cverdefs == 0
2566 || this_hdr->sh_info == elf_tdata (abfd)->cverdefs);
2f89ff8d
L		 2567 break;
2568
2569 case SHT_GNU_verneed:
252b5132
RH		 2570 this_hdr->sh_entsize = 0;
2571 /* objcopy or strip will copy over sh_info, but may not set
08a40648
AM		 2572 cverrefs. The linker will set cverrefs, but sh_info will be
2573 zero. */
252b5132
RH		 2574 if (this_hdr->sh_info == 0)
2575 this_hdr->sh_info = elf_tdata (abfd)->cverrefs;
2576 else
2577 BFD_ASSERT (elf_tdata (abfd)->cverrefs == 0
2578 || this_hdr->sh_info == elf_tdata (abfd)->cverrefs);
2f89ff8d
L		 2579 break;
2580
2581 case SHT_GROUP:
1783205a 2582 this_hdr->sh_entsize = GRP_ENTRY_SIZE;
2f89ff8d 2583 break;
fdc90cb4
JJ		 2584
2585 case SHT_GNU_HASH:
2586 this_hdr->sh_entsize = bed->s->arch_size == 64 ? 0 : 4;
2587 break;
dbb410c3 2588 }
252b5132
RH		 2589
2590 if ((asect->flags & SEC_ALLOC) != 0)
2591 this_hdr->sh_flags |= SHF_ALLOC;
2592 if ((asect->flags & SEC_READONLY) == 0)
2593 this_hdr->sh_flags |= SHF_WRITE;
2594 if ((asect->flags & SEC_CODE) != 0)
2595 this_hdr->sh_flags |= SHF_EXECINSTR;
f5fa8ca2
JJ		 2596 if ((asect->flags & SEC_MERGE) != 0)
2597 {
2598 this_hdr->sh_flags |= SHF_MERGE;
2599 this_hdr->sh_entsize = asect->entsize;
2600 if ((asect->flags & SEC_STRINGS) != 0)
2601 this_hdr->sh_flags |= SHF_STRINGS;
2602 }
1126897b 2603 if ((asect->flags & SEC_GROUP) == 0 && elf_group_name (asect) != NULL)
dbb410c3 2604 this_hdr->sh_flags |= SHF_GROUP;
13ae64f3 2605 if ((asect->flags & SEC_THREAD_LOCAL) != 0)
704afa60
JJ		 2606 {
2607 this_hdr->sh_flags |= SHF_TLS;
3a800eb9
AM		 2608 if (asect->size == 0
2609 && (asect->flags & SEC_HAS_CONTENTS) == 0)
704afa60 2610 {
3a800eb9 2611 struct bfd_link_order *o = asect->map_tail.link_order;
b34976b6 2612
704afa60 2613 this_hdr->sh_size = 0;
3a800eb9
AM		 2614 if (o != NULL)
2615 {
704afa60 2616 this_hdr->sh_size = o->offset + o->size;
3a800eb9
AM		 2617 if (this_hdr->sh_size != 0)
2618 this_hdr->sh_type = SHT_NOBITS;
2619 }
704afa60
JJ		 2620 }
2621 }
252b5132
RH		 2622
2623 /* Check for processor-specific section types. */
0414f35b 2624 sh_type = this_hdr->sh_type;
e1fddb6b
AO		 2625 if (bed->elf_backend_fake_sections
2626 && !(*bed->elf_backend_fake_sections) (abfd, this_hdr, asect))
b34976b6 2627 *failedptr = TRUE;
252b5132 2628
42bb2e33 2629 if (sh_type == SHT_NOBITS && asect->size != 0)
0414f35b
AM		 2630 {
2631 /* Don't change the header type from NOBITS if we are being
42bb2e33 2632 called for objcopy --only-keep-debug. */
0414f35b
AM		 2633 this_hdr->sh_type = sh_type;
2634 }
2635
252b5132 2636 /* If the section has relocs, set up a section header for the
23bc299b
MM		 2637 SHT_REL[A] section. If two relocation sections are required for
2638 this section, it is up to the processor-specific back-end to
c044fabd 2639 create the other. */
23bc299b 2640 if ((asect->flags & SEC_RELOC) != 0
c044fabd 2641 && !_bfd_elf_init_reloc_shdr (abfd,
23bc299b 2642 &elf_section_data (asect)->rel_hdr,
c044fabd 2643 asect,
68bfbfcc 2644 asect->use_rela_p))
b34976b6 2645 *failedptr = TRUE;
252b5132
RH		 2646}
2647
bcacc0f5
AM		 2648/* Fill in the contents of a SHT_GROUP section. Called from
2649 _bfd_elf_compute_section_file_positions for gas, objcopy, and
2650 when ELF targets use the generic linker, ld. Called for ld -r
2651 from bfd_elf_final_link. */
dbb410c3 2652
1126897b 2653void
217aa764 2654bfd_elf_set_group_contents (bfd *abfd, asection *sec, void *failedptrarg)
dbb410c3 2655{
217aa764 2656 bfd_boolean *failedptr = failedptrarg;
9dce4196 2657 asection *elt, *first;
dbb410c3 2658 unsigned char *loc;
b34976b6 2659 bfd_boolean gas;
dbb410c3 2660
7e4111ad
L		 2661 /* Ignore linker created group section. See elfNN_ia64_object_p in
2662 elfxx-ia64.c. */
2663 if (((sec->flags & (SEC_GROUP | SEC_LINKER_CREATED)) != SEC_GROUP)
dbb410c3
AM		 2664 || *failedptr)
2665 return;
2666
bcacc0f5
AM		 2667 if (elf_section_data (sec)->this_hdr.sh_info == 0)
2668 {
2669 unsigned long symindx = 0;
2670
2671 /* elf_group_id will have been set up by objcopy and the
2672 generic linker. */
2673 if (elf_group_id (sec) != NULL)
2674 symindx = elf_group_id (sec)->udata.i;
1126897b 2675
bcacc0f5
AM		 2676 if (symindx == 0)
2677 {
2678 /* If called from the assembler, swap_out_syms will have set up
2679 elf_section_syms. */
2680 BFD_ASSERT (elf_section_syms (abfd) != NULL);
2681 symindx = elf_section_syms (abfd)[sec->index]->udata.i;
2682 }
2683 elf_section_data (sec)->this_hdr.sh_info = symindx;
2684 }
2685 else if (elf_section_data (sec)->this_hdr.sh_info == (unsigned int) -2)
1126897b 2686 {
bcacc0f5
AM		 2687 /* The ELF backend linker sets sh_info to -2 when the group
2688 signature symbol is global, and thus the index can't be
2689 set until all local symbols are output. */
2690 asection *igroup = elf_sec_group (elf_next_in_group (sec));
2691 struct bfd_elf_section_data *sec_data = elf_section_data (igroup);
2692 unsigned long symndx = sec_data->this_hdr.sh_info;
2693 unsigned long extsymoff = 0;
2694 struct elf_link_hash_entry *h;
2695
2696 if (!elf_bad_symtab (igroup->owner))
2697 {
2698 Elf_Internal_Shdr *symtab_hdr;
2699
2700 symtab_hdr = &elf_tdata (igroup->owner)->symtab_hdr;
2701 extsymoff = symtab_hdr->sh_info;
2702 }
2703 h = elf_sym_hashes (igroup->owner)[symndx - extsymoff];
2704 while (h->root.type == bfd_link_hash_indirect
2705 || h->root.type == bfd_link_hash_warning)
2706 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2707
2708 elf_section_data (sec)->this_hdr.sh_info = h->indx;
1126897b 2709 }
dbb410c3 2710
1126897b 2711 /* The contents won't be allocated for "ld -r" or objcopy. */
b34976b6 2712 gas = TRUE;
dbb410c3
AM		 2713 if (sec->contents == NULL)
2714 {
b34976b6 2715 gas = FALSE;
eea6121a 2716 sec->contents = bfd_alloc (abfd, sec->size);
9dce4196
AM		 2717
2718 /* Arrange for the section to be written out. */
2719 elf_section_data (sec)->this_hdr.contents = sec->contents;
dbb410c3
AM		 2720 if (sec->contents == NULL)
2721 {
b34976b6 2722 *failedptr = TRUE;
dbb410c3
AM		 2723 return;
2724 }
2725 }
2726
eea6121a 2727 loc = sec->contents + sec->size;
dbb410c3 2728
9dce4196
AM		 2729 /* Get the pointer to the first section in the group that gas
2730 squirreled away here. objcopy arranges for this to be set to the
2731 start of the input section group. */
2732 first = elt = elf_next_in_group (sec);
dbb410c3
AM		 2733
2734 /* First element is a flag word. Rest of section is elf section
2735 indices for all the sections of the group. Write them backwards
2736 just to keep the group in the same order as given in .section
2737 directives, not that it matters. */
2738 while (elt != NULL)
2739 {
9dce4196
AM		 2740 asection *s;
2741 unsigned int idx;
2742
9dce4196 2743 s = elt;
01e1a5bc
NC		 2744 if (! elf_discarded_section (s))
2745 {
2746 loc -= 4;
2747 if (!gas)
2748 s = s->output_section;
2749 idx = 0;
2750 if (s != NULL)
2751 idx = elf_section_data (s)->this_idx;
2752 H_PUT_32 (abfd, idx, loc);
2753 }
945906ff 2754 elt = elf_next_in_group (elt);
9dce4196
AM		 2755 if (elt == first)
2756 break;
dbb410c3
AM		 2757 }
2758
3d7f7666 2759 if ((loc -= 4) != sec->contents)
9dce4196 2760 abort ();
dbb410c3 2761
9dce4196 2762 H_PUT_32 (abfd, sec->flags & SEC_LINK_ONCE ? GRP_COMDAT : 0, loc);
dbb410c3
AM		 2763}
2764
252b5132
RH		 2765/* Assign all ELF section numbers. The dummy first section is handled here
2766 too. The link/info pointers for the standard section types are filled
2767 in here too, while we're at it. */
2768
b34976b6 2769static bfd_boolean
da9f89d4 2770assign_section_numbers (bfd *abfd, struct bfd_link_info *link_info)
252b5132
RH		 2771{
2772 struct elf_obj_tdata *t = elf_tdata (abfd);
2773 asection *sec;
2b0f7ef9 2774 unsigned int section_number, secn;
252b5132 2775 Elf_Internal_Shdr **i_shdrp;
47cc2cf5 2776 struct bfd_elf_section_data *d;
252b5132
RH		 2777
2778 section_number = 1;
2779
2b0f7ef9
JJ		 2780 _bfd_elf_strtab_clear_all_refs (elf_shstrtab (abfd));
2781
da9f89d4
L		 2782 /* SHT_GROUP sections are in relocatable files only. */
2783 if (link_info == NULL || link_info->relocatable)
252b5132 2784 {
da9f89d4 2785 /* Put SHT_GROUP sections first. */
04dd1667 2786 for (sec = abfd->sections; sec != NULL; sec = sec->next)
47cc2cf5 2787 {
5daa8fe7 2788 d = elf_section_data (sec);
da9f89d4
L		 2789
2790 if (d->this_hdr.sh_type == SHT_GROUP)
08a40648 2791 {
5daa8fe7 2792 if (sec->flags & SEC_LINKER_CREATED)
da9f89d4
L		 2793 {
2794 /* Remove the linker created SHT_GROUP sections. */
5daa8fe7 2795 bfd_section_list_remove (abfd, sec);
da9f89d4 2796 abfd->section_count--;
da9f89d4 2797 }
08a40648 2798 else
4fbb74a6 2799 d->this_idx = section_number++;
da9f89d4 2800 }
47cc2cf5
PB		 2801 }
2802 }
2803
2804 for (sec = abfd->sections; sec; sec = sec->next)
2805 {
2806 d = elf_section_data (sec);
2807
2808 if (d->this_hdr.sh_type != SHT_GROUP)
4fbb74a6 2809 d->this_idx = section_number++;
2b0f7ef9 2810 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->this_hdr.sh_name);
252b5132
RH		 2811 if ((sec->flags & SEC_RELOC) == 0)
2812 d->rel_idx = 0;
2813 else
2b0f7ef9
JJ		 2814 {
2815 d->rel_idx = section_number++;
2816 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr.sh_name);
2817 }
23bc299b
MM		 2818
2819 if (d->rel_hdr2)
2b0f7ef9
JJ		 2820 {
2821 d->rel_idx2 = section_number++;
2822 _bfd_elf_strtab_addref (elf_shstrtab (abfd), d->rel_hdr2->sh_name);
2823 }
23bc299b
MM		 2824 else
2825 d->rel_idx2 = 0;
252b5132
RH		 2826 }
2827
2828 t->shstrtab_section = section_number++;
2b0f7ef9 2829 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->shstrtab_hdr.sh_name);
252b5132 2830 elf_elfheader (abfd)->e_shstrndx = t->shstrtab_section;
252b5132
RH		 2831
2832 if (bfd_get_symcount (abfd) > 0)
2833 {
2834 t->symtab_section = section_number++;
2b0f7ef9 2835 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->symtab_hdr.sh_name);
4fbb74a6 2836 if (section_number > ((SHN_LORESERVE - 2) & 0xFFFF))
9ad5cbcf 2837 {
9ad5cbcf
AM		 2838 t->symtab_shndx_section = section_number++;
2839 t->symtab_shndx_hdr.sh_name
2840 = (unsigned int) _bfd_elf_strtab_add (elf_shstrtab (abfd),
b34976b6 2841 ".symtab_shndx", FALSE);
9ad5cbcf 2842 if (t->symtab_shndx_hdr.sh_name == (unsigned int) -1)
b34976b6 2843 return FALSE;
9ad5cbcf 2844 }
252b5132 2845 t->strtab_section = section_number++;
2b0f7ef9 2846 _bfd_elf_strtab_addref (elf_shstrtab (abfd), t->strtab_hdr.sh_name);
252b5132
RH		 2847 }
2848
2b0f7ef9
JJ		 2849 _bfd_elf_strtab_finalize (elf_shstrtab (abfd));
2850 t->shstrtab_hdr.sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
9ad5cbcf
AM		 2851
2852 elf_numsections (abfd) = section_number;
252b5132
RH		 2853 elf_elfheader (abfd)->e_shnum = section_number;
2854
2855 /* Set up the list of section header pointers, in agreement with the
2856 indices. */
d0fb9a8d 2857 i_shdrp = bfd_zalloc2 (abfd, section_number, sizeof (Elf_Internal_Shdr *));
252b5132 2858 if (i_shdrp == NULL)
b34976b6 2859 return FALSE;
252b5132 2860
d0fb9a8d 2861 i_shdrp[0] = bfd_zalloc (abfd, sizeof (Elf_Internal_Shdr));
252b5132
RH		 2862 if (i_shdrp[0] == NULL)
2863 {
2864 bfd_release (abfd, i_shdrp);
b34976b6 2865 return FALSE;
252b5132 2866 }
252b5132
RH		 2867
2868 elf_elfsections (abfd) = i_shdrp;
2869
2870 i_shdrp[t->shstrtab_section] = &t->shstrtab_hdr;
2871 if (bfd_get_symcount (abfd) > 0)
2872 {
2873 i_shdrp[t->symtab_section] = &t->symtab_hdr;
4fbb74a6 2874 if (elf_numsections (abfd) > (SHN_LORESERVE & 0xFFFF))
9ad5cbcf
AM		 2875 {
2876 i_shdrp[t->symtab_shndx_section] = &t->symtab_shndx_hdr;
2877 t->symtab_shndx_hdr.sh_link = t->symtab_section;
2878 }
252b5132
RH		 2879 i_shdrp[t->strtab_section] = &t->strtab_hdr;
2880 t->symtab_hdr.sh_link = t->strtab_section;
2881 }
38ce5b11 2882
252b5132
RH		 2883 for (sec = abfd->sections; sec; sec = sec->next)
2884 {
2885 struct bfd_elf_section_data *d = elf_section_data (sec);
2886 asection *s;
2887 const char *name;
2888
2889 i_shdrp[d->this_idx] = &d->this_hdr;
2890 if (d->rel_idx != 0)
2891 i_shdrp[d->rel_idx] = &d->rel_hdr;
23bc299b
MM		 2892 if (d->rel_idx2 != 0)
2893 i_shdrp[d->rel_idx2] = d->rel_hdr2;
252b5132
RH		 2894
2895 /* Fill in the sh_link and sh_info fields while we're at it. */
2896
2897 /* sh_link of a reloc section is the section index of the symbol
2898 table. sh_info is the section index of the section to which
2899 the relocation entries apply. */
2900 if (d->rel_idx != 0)
2901 {
2902 d->rel_hdr.sh_link = t->symtab_section;
2903 d->rel_hdr.sh_info = d->this_idx;
2904 }
23bc299b
MM		 2905 if (d->rel_idx2 != 0)
2906 {
2907 d->rel_hdr2->sh_link = t->symtab_section;
2908 d->rel_hdr2->sh_info = d->this_idx;
2909 }
252b5132 2910
38ce5b11
L		 2911 /* We need to set up sh_link for SHF_LINK_ORDER. */
2912 if ((d->this_hdr.sh_flags & SHF_LINK_ORDER) != 0)
2913 {
2914 s = elf_linked_to_section (sec);
2915 if (s)
38ce5b11 2916 {
f2876037 2917 /* elf_linked_to_section points to the input section. */
ccd2ec6a 2918 if (link_info != NULL)
38ce5b11 2919 {
f2876037 2920 /* Check discarded linkonce section. */
ccd2ec6a 2921 if (elf_discarded_section (s))
38ce5b11 2922 {
ccd2ec6a
L		 2923 asection *kept;
2924 (*_bfd_error_handler)
2925 (_("%B: sh_link of section `%A' points to discarded section `%A' of `%B'"),
2926 abfd, d->this_hdr.bfd_section,
2927 s, s->owner);
2928 /* Point to the kept section if it has the same
2929 size as the discarded one. */
c0f00686 2930 kept = _bfd_elf_check_kept_section (s, link_info);
ccd2ec6a 2931 if (kept == NULL)
185d09ad 2932 {
ccd2ec6a
L		 2933 bfd_set_error (bfd_error_bad_value);
2934 return FALSE;
185d09ad 2935 }
ccd2ec6a 2936 s = kept;
38ce5b11 2937 }
e424ecc8 2938
ccd2ec6a
L		 2939 s = s->output_section;
2940 BFD_ASSERT (s != NULL);
38ce5b11 2941 }
f2876037
L		 2942 else
2943 {
2944 /* Handle objcopy. */
2945 if (s->output_section == NULL)
2946 {
2947 (*_bfd_error_handler)
2948 (_("%B: sh_link of section `%A' points to removed section `%A' of `%B'"),
2949 abfd, d->this_hdr.bfd_section, s, s->owner);
2950 bfd_set_error (bfd_error_bad_value);
2951 return FALSE;
2952 }
2953 s = s->output_section;
2954 }
ccd2ec6a
L		 2955 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2956 }
2957 else
2958 {
2959 /* PR 290:
2960 The Intel C compiler generates SHT_IA_64_UNWIND with
2961 SHF_LINK_ORDER. But it doesn't set the sh_link or
2962 sh_info fields. Hence we could get the situation
08a40648 2963 where s is NULL. */
ccd2ec6a
L		 2964 const struct elf_backend_data *bed
2965 = get_elf_backend_data (abfd);
2966 if (bed->link_order_error_handler)
2967 bed->link_order_error_handler
2968 (_("%B: warning: sh_link not set for section `%A'"),
2969 abfd, sec);
38ce5b11
L		 2970 }
2971 }
2972
252b5132
RH		 2973 switch (d->this_hdr.sh_type)
2974 {
2975 case SHT_REL:
2976 case SHT_RELA:
2977 /* A reloc section which we are treating as a normal BFD
2978 section. sh_link is the section index of the symbol
2979 table. sh_info is the section index of the section to
2980 which the relocation entries apply. We assume that an
2981 allocated reloc section uses the dynamic symbol table.
2982 FIXME: How can we be sure? */
2983 s = bfd_get_section_by_name (abfd, ".dynsym");
2984 if (s != NULL)
2985 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
2986
2987 /* We look up the section the relocs apply to by name. */
2988 name = sec->name;
2989 if (d->this_hdr.sh_type == SHT_REL)
2990 name += 4;
2991 else
2992 name += 5;
2993 s = bfd_get_section_by_name (abfd, name);
2994 if (s != NULL)
2995 d->this_hdr.sh_info = elf_section_data (s)->this_idx;
2996 break;
2997
2998 case SHT_STRTAB:
2999 /* We assume that a section named .stab*str is a stabs
3000 string section. We look for a section with the same name
3001 but without the trailing ``str'', and set its sh_link
3002 field to point to this section. */
0112cd26 3003 if (CONST_STRNEQ (sec->name, ".stab")
252b5132
RH		 3004 && strcmp (sec->name + strlen (sec->name) - 3, "str") == 0)
3005 {
3006 size_t len;
3007 char *alc;
3008
3009 len = strlen (sec->name);
217aa764 3010 alc = bfd_malloc (len - 2);
252b5132 3011 if (alc == NULL)
b34976b6 3012 return FALSE;
d4c88bbb 3013 memcpy (alc, sec->name, len - 3);
252b5132
RH		 3014 alc[len - 3] = '\0';
3015 s = bfd_get_section_by_name (abfd, alc);
3016 free (alc);
3017 if (s != NULL)
3018 {
3019 elf_section_data (s)->this_hdr.sh_link = d->this_idx;
3020
3021 /* This is a .stab section. */
0594c12d
AM		 3022 if (elf_section_data (s)->this_hdr.sh_entsize == 0)
3023 elf_section_data (s)->this_hdr.sh_entsize
3024 = 4 + 2 * bfd_get_arch_size (abfd) / 8;
252b5132
RH		 3025 }
3026 }
3027 break;
3028
3029 case SHT_DYNAMIC:
3030 case SHT_DYNSYM:
3031 case SHT_GNU_verneed:
3032 case SHT_GNU_verdef:
3033 /* sh_link is the section header index of the string table
3034 used for the dynamic entries, or the symbol table, or the
3035 version strings. */
3036 s = bfd_get_section_by_name (abfd, ".dynstr");
3037 if (s != NULL)
3038 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3039 break;
3040
7f1204bb
JJ		 3041 case SHT_GNU_LIBLIST:
3042 /* sh_link is the section header index of the prelink library
08a40648
AM		 3043 list used for the dynamic entries, or the symbol table, or
3044 the version strings. */
7f1204bb
JJ		 3045 s = bfd_get_section_by_name (abfd, (sec->flags & SEC_ALLOC)
3046 ? ".dynstr" : ".gnu.libstr");
3047 if (s != NULL)
3048 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3049 break;
3050
252b5132 3051 case SHT_HASH:
fdc90cb4 3052 case SHT_GNU_HASH:
252b5132
RH		 3053 case SHT_GNU_versym:
3054 /* sh_link is the section header index of the symbol table
3055 this hash table or version table is for. */
3056 s = bfd_get_section_by_name (abfd, ".dynsym");
3057 if (s != NULL)
3058 d->this_hdr.sh_link = elf_section_data (s)->this_idx;
3059 break;
dbb410c3
AM		 3060
3061 case SHT_GROUP:
3062 d->this_hdr.sh_link = t->symtab_section;
252b5132
RH		 3063 }
3064 }
3065
2b0f7ef9 3066 for (secn = 1; secn < section_number; ++secn)
9ad5cbcf
AM		 3067 if (i_shdrp[secn] == NULL)
3068 i_shdrp[secn] = i_shdrp[0];
3069 else
3070 i_shdrp[secn]->sh_name = _bfd_elf_strtab_offset (elf_shstrtab (abfd),
3071 i_shdrp[secn]->sh_name);
b34976b6 3072 return TRUE;
252b5132
RH		 3073}
3074
3075/* Map symbol from it's internal number to the external number, moving
3076 all local symbols to be at the head of the list. */
3077
5372391b 3078static bfd_boolean
217aa764 3079sym_is_global (bfd *abfd, asymbol *sym)
252b5132
RH		 3080{
3081 /* If the backend has a special mapping, use it. */
9c5bfbb7 3082 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764
AM		 3083 if (bed->elf_backend_sym_is_global)
3084 return (*bed->elf_backend_sym_is_global) (abfd, sym);
252b5132
RH		 3085
3086 return ((sym->flags & (BSF_GLOBAL | BSF_WEAK)) != 0
3087 || bfd_is_und_section (bfd_get_section (sym))
3088 || bfd_is_com_section (bfd_get_section (sym)));
3089}
3090
5372391b 3091/* Don't output section symbols for sections that are not going to be
0f0a5e58 3092 output. */
5372391b
AM		 3093
3094static bfd_boolean
3095ignore_section_sym (bfd *abfd, asymbol *sym)
3096{
3097 return ((sym->flags & BSF_SECTION_SYM) != 0
0f0a5e58
AM		 3098 && !(sym->section->owner == abfd
3099 || (sym->section->output_section->owner == abfd
3100 && sym->section->output_offset == 0)));
5372391b
AM		 3101}
3102
b34976b6 3103static bfd_boolean
217aa764 3104elf_map_symbols (bfd *abfd)
252b5132 3105{
dc810e39 3106 unsigned int symcount = bfd_get_symcount (abfd);
252b5132
RH		 3107 asymbol **syms = bfd_get_outsymbols (abfd);
3108 asymbol **sect_syms;
dc810e39
AM		 3109 unsigned int num_locals = 0;
3110 unsigned int num_globals = 0;
3111 unsigned int num_locals2 = 0;
3112 unsigned int num_globals2 = 0;
252b5132 3113 int max_index = 0;
dc810e39 3114 unsigned int idx;
252b5132
RH		 3115 asection *asect;
3116 asymbol **new_syms;
252b5132
RH		 3117
3118#ifdef DEBUG
3119 fprintf (stderr, "elf_map_symbols\n");
3120 fflush (stderr);
3121#endif
3122
252b5132
RH		 3123 for (asect = abfd->sections; asect; asect = asect->next)
3124 {
3125 if (max_index < asect->index)
3126 max_index = asect->index;
3127 }
3128
3129 max_index++;
d0fb9a8d 3130 sect_syms = bfd_zalloc2 (abfd, max_index, sizeof (asymbol *));
252b5132 3131 if (sect_syms == NULL)
b34976b6 3132 return FALSE;
252b5132 3133 elf_section_syms (abfd) = sect_syms;
4e89ac30 3134 elf_num_section_syms (abfd) = max_index;
252b5132 3135
079e9a2f
AM		 3136 /* Init sect_syms entries for any section symbols we have already
3137 decided to output. */
252b5132
RH		 3138 for (idx = 0; idx < symcount; idx++)
3139 {
dc810e39 3140 asymbol *sym = syms[idx];
c044fabd 3141
252b5132 3142 if ((sym->flags & BSF_SECTION_SYM) != 0
0f0a5e58 3143 && sym->value == 0
5372391b 3144 && !ignore_section_sym (abfd, sym))
252b5132 3145 {
5372391b 3146 asection *sec = sym->section;
252b5132 3147
5372391b
AM		 3148 if (sec->owner != abfd)
3149 sec = sec->output_section;
252b5132 3150
5372391b 3151 sect_syms[sec->index] = syms[idx];
252b5132
RH		 3152 }
3153 }
3154
252b5132
RH		 3155 /* Classify all of the symbols. */
3156 for (idx = 0; idx < symcount; idx++)
3157 {
5372391b
AM		 3158 if (ignore_section_sym (abfd, syms[idx]))
3159 continue;
252b5132
RH		 3160 if (!sym_is_global (abfd, syms[idx]))
3161 num_locals++;
3162 else
3163 num_globals++;
3164 }
079e9a2f 3165
5372391b 3166 /* We will be adding a section symbol for each normal BFD section. Most
079e9a2f
AM		 3167 sections will already have a section symbol in outsymbols, but
3168 eg. SHT_GROUP sections will not, and we need the section symbol mapped
3169 at least in that case. */
252b5132
RH		 3170 for (asect = abfd->sections; asect; asect = asect->next)
3171 {
079e9a2f 3172 if (sect_syms[asect->index] == NULL)
252b5132 3173 {
079e9a2f 3174 if (!sym_is_global (abfd, asect->symbol))
252b5132
RH		 3175 num_locals++;
3176 else
3177 num_globals++;
252b5132
RH		 3178 }
3179 }
3180
3181 /* Now sort the symbols so the local symbols are first. */
d0fb9a8d 3182 new_syms = bfd_alloc2 (abfd, num_locals + num_globals, sizeof (asymbol *));
dc810e39 3183
252b5132 3184 if (new_syms == NULL)
b34976b6 3185 return FALSE;
252b5132
RH		 3186
3187 for (idx = 0; idx < symcount; idx++)
3188 {
3189 asymbol *sym = syms[idx];
dc810e39 3190 unsigned int i;
252b5132 3191
5372391b
AM		 3192 if (ignore_section_sym (abfd, sym))
3193 continue;
252b5132
RH		 3194 if (!sym_is_global (abfd, sym))
3195 i = num_locals2++;
3196 else
3197 i = num_locals + num_globals2++;
3198 new_syms[i] = sym;
3199 sym->udata.i = i + 1;
3200 }
3201 for (asect = abfd->sections; asect; asect = asect->next)
3202 {
079e9a2f 3203 if (sect_syms[asect->index] == NULL)
252b5132 3204 {
079e9a2f 3205 asymbol *sym = asect->symbol;
dc810e39 3206 unsigned int i;
252b5132 3207
079e9a2f 3208 sect_syms[asect->index] = sym;
252b5132
RH		 3209 if (!sym_is_global (abfd, sym))
3210 i = num_locals2++;
3211 else
3212 i = num_locals + num_globals2++;
3213 new_syms[i] = sym;
3214 sym->udata.i = i + 1;
3215 }
3216 }
3217
3218 bfd_set_symtab (abfd, new_syms, num_locals + num_globals);
3219
3220 elf_num_locals (abfd) = num_locals;
3221 elf_num_globals (abfd) = num_globals;
b34976b6 3222 return TRUE;
252b5132
RH		 3223}
3224
3225/* Align to the maximum file alignment that could be required for any
3226 ELF data structure. */
3227
268b6b39 3228static inline file_ptr
217aa764 3229align_file_position (file_ptr off, int align)
252b5132
RH		 3230{
3231 return (off + align - 1) & ~(align - 1);
3232}
3233
3234/* Assign a file position to a section, optionally aligning to the
3235 required section alignment. */
3236
217aa764
AM		 3237file_ptr
3238_bfd_elf_assign_file_position_for_section (Elf_Internal_Shdr *i_shdrp,
3239 file_ptr offset,
3240 bfd_boolean align)
252b5132 3241{
72de5009
AM		 3242 if (align && i_shdrp->sh_addralign > 1)
3243 offset = BFD_ALIGN (offset, i_shdrp->sh_addralign);
252b5132
RH		 3244 i_shdrp->sh_offset = offset;
3245 if (i_shdrp->bfd_section != NULL)
3246 i_shdrp->bfd_section->filepos = offset;
3247 if (i_shdrp->sh_type != SHT_NOBITS)
3248 offset += i_shdrp->sh_size;
3249 return offset;
3250}
3251
3252/* Compute the file positions we are going to put the sections at, and
3253 otherwise prepare to begin writing out the ELF file. If LINK_INFO
3254 is not NULL, this is being called by the ELF backend linker. */
3255
b34976b6 3256bfd_boolean
217aa764
AM		 3257_bfd_elf_compute_section_file_positions (bfd *abfd,
3258 struct bfd_link_info *link_info)
252b5132 3259{
9c5bfbb7 3260 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
b34976b6 3261 bfd_boolean failed;
4b6c0f2f 3262 struct bfd_strtab_hash *strtab = NULL;
252b5132
RH		 3263 Elf_Internal_Shdr *shstrtab_hdr;
3264
3265 if (abfd->output_has_begun)
b34976b6 3266 return TRUE;
252b5132
RH		 3267
3268 /* Do any elf backend specific processing first. */
3269 if (bed->elf_backend_begin_write_processing)
3270 (*bed->elf_backend_begin_write_processing) (abfd, link_info);
3271
3272 if (! prep_headers (abfd))
b34976b6 3273 return FALSE;
252b5132 3274
e6c51ed4
NC		 3275 /* Post process the headers if necessary. */
3276 if (bed->elf_backend_post_process_headers)
3277 (*bed->elf_backend_post_process_headers) (abfd, link_info);
3278
b34976b6 3279 failed = FALSE;
252b5132
RH		 3280 bfd_map_over_sections (abfd, elf_fake_sections, &failed);
3281 if (failed)
b34976b6 3282 return FALSE;
252b5132 3283
da9f89d4 3284 if (!assign_section_numbers (abfd, link_info))
b34976b6 3285 return FALSE;
252b5132
RH		 3286
3287 /* The backend linker builds symbol table information itself. */
3288 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3289 {
3290 /* Non-zero if doing a relocatable link. */
3291 int relocatable_p = ! (abfd->flags & (EXEC_P | DYNAMIC));
3292
3293 if (! swap_out_syms (abfd, &strtab, relocatable_p))
b34976b6 3294 return FALSE;
252b5132
RH		 3295 }
3296
1126897b 3297 if (link_info == NULL)
dbb410c3 3298 {
1126897b 3299 bfd_map_over_sections (abfd, bfd_elf_set_group_contents, &failed);
dbb410c3 3300 if (failed)
b34976b6 3301 return FALSE;
dbb410c3
AM		 3302 }
3303
252b5132
RH		 3304 shstrtab_hdr = &elf_tdata (abfd)->shstrtab_hdr;
3305 /* sh_name was set in prep_headers. */
3306 shstrtab_hdr->sh_type = SHT_STRTAB;
3307 shstrtab_hdr->sh_flags = 0;
3308 shstrtab_hdr->sh_addr = 0;
2b0f7ef9 3309 shstrtab_hdr->sh_size = _bfd_elf_strtab_size (elf_shstrtab (abfd));
252b5132
RH		 3310 shstrtab_hdr->sh_entsize = 0;
3311 shstrtab_hdr->sh_link = 0;
3312 shstrtab_hdr->sh_info = 0;
3313 /* sh_offset is set in assign_file_positions_except_relocs. */
3314 shstrtab_hdr->sh_addralign = 1;
3315
c84fca4d 3316 if (!assign_file_positions_except_relocs (abfd, link_info))
b34976b6 3317 return FALSE;
252b5132
RH		 3318
3319 if (link_info == NULL && bfd_get_symcount (abfd) > 0)
3320 {
3321 file_ptr off;
3322 Elf_Internal_Shdr *hdr;
3323
3324 off = elf_tdata (abfd)->next_file_pos;
3325
3326 hdr = &elf_tdata (abfd)->symtab_hdr;
b34976b6 3327 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 3328
9ad5cbcf
AM		 3329 hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
3330 if (hdr->sh_size != 0)
b34976b6 3331 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
9ad5cbcf 3332
252b5132 3333 hdr = &elf_tdata (abfd)->strtab_hdr;
b34976b6 3334 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132
RH		 3335
3336 elf_tdata (abfd)->next_file_pos = off;
3337
3338 /* Now that we know where the .strtab section goes, write it
08a40648 3339 out. */
252b5132
RH		 3340 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
3341 || ! _bfd_stringtab_emit (abfd, strtab))
b34976b6 3342 return FALSE;
252b5132
RH		 3343 _bfd_stringtab_free (strtab);
3344 }
3345
b34976b6 3346 abfd->output_has_begun = TRUE;
252b5132 3347
b34976b6 3348 return TRUE;
252b5132
RH		 3349}
3350
8ded5a0f
AM		 3351/* Make an initial estimate of the size of the program header. If we
3352 get the number wrong here, we'll redo section placement. */
3353
3354static bfd_size_type
3355get_program_header_size (bfd *abfd, struct bfd_link_info *info)
3356{
3357 size_t segs;
3358 asection *s;
2b05f1b7 3359 const struct elf_backend_data *bed;
8ded5a0f
AM		 3360
3361 /* Assume we will need exactly two PT_LOAD segments: one for text
3362 and one for data. */
3363 segs = 2;
3364
3365 s = bfd_get_section_by_name (abfd, ".interp");
3366 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3367 {
3368 /* If we have a loadable interpreter section, we need a
3369 PT_INTERP segment. In this case, assume we also need a
3370 PT_PHDR segment, although that may not be true for all
3371 targets. */
3372 segs += 2;
3373 }
3374
3375 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
3376 {
3377 /* We need a PT_DYNAMIC segment. */
3378 ++segs;
f210dcff 3379 }
08a40648 3380
ceae84aa 3381 if (info != NULL && info->relro)
f210dcff
L		 3382 {
3383 /* We need a PT_GNU_RELRO segment. */
3384 ++segs;
8ded5a0f
AM		 3385 }
3386
3387 if (elf_tdata (abfd)->eh_frame_hdr)
3388 {
3389 /* We need a PT_GNU_EH_FRAME segment. */
3390 ++segs;
3391 }
3392
2b05f1b7 3393 if (elf_tdata (abfd)->stack_flags)
8ded5a0f 3394 {
2b05f1b7
L		 3395 /* We need a PT_GNU_STACK segment. */
3396 ++segs;
3397 }
94b11780 3398
2b05f1b7
L		 3399 for (s = abfd->sections; s != NULL; s = s->next)
3400 {
8ded5a0f 3401 if ((s->flags & SEC_LOAD) != 0
0112cd26 3402 && CONST_STRNEQ (s->name, ".note"))
8ded5a0f
AM		 3403 {
3404 /* We need a PT_NOTE segment. */
3405 ++segs;
1c5265b5
JJ		 3406 /* Try to create just one PT_NOTE segment
3407 for all adjacent loadable .note* sections.
3408 gABI requires that within a PT_NOTE segment
3409 (and also inside of each SHT_NOTE section)
3410 each note is padded to a multiple of 4 size,
3411 so we check whether the sections are correctly
3412 aligned. */
3413 if (s->alignment_power == 2)
3414 while (s->next != NULL
3415 && s->next->alignment_power == 2
3416 && (s->next->flags & SEC_LOAD) != 0
3417 && CONST_STRNEQ (s->next->name, ".note"))
3418 s = s->next;
8ded5a0f
AM		 3419 }
3420 }
3421
3422 for (s = abfd->sections; s != NULL; s = s->next)
3423 {
3424 if (s->flags & SEC_THREAD_LOCAL)
3425 {
3426 /* We need a PT_TLS segment. */
3427 ++segs;
3428 break;
3429 }
3430 }
3431
3432 /* Let the backend count up any program headers it might need. */
2b05f1b7 3433 bed = get_elf_backend_data (abfd);
8ded5a0f
AM		 3434 if (bed->elf_backend_additional_program_headers)
3435 {
3436 int a;
3437
3438 a = (*bed->elf_backend_additional_program_headers) (abfd, info);
3439 if (a == -1)
3440 abort ();
3441 segs += a;
3442 }
3443
3444 return segs * bed->s->sizeof_phdr;
3445}
3446
2ea37f1c
NC		 3447/* Find the segment that contains the output_section of section. */
3448
3449Elf_Internal_Phdr *
3450_bfd_elf_find_segment_containing_section (bfd * abfd, asection * section)
3451{
3452 struct elf_segment_map *m;
3453 Elf_Internal_Phdr *p;
3454
3455 for (m = elf_tdata (abfd)->segment_map,
3456 p = elf_tdata (abfd)->phdr;
3457 m != NULL;
3458 m = m->next, p++)
3459 {
3460 int i;
3461
3462 for (i = m->count - 1; i >= 0; i--)
3463 if (m->sections[i] == section)
3464 return p;
3465 }
3466
3467 return NULL;
3468}
3469
252b5132
RH		 3470/* Create a mapping from a set of sections to a program segment. */
3471
217aa764
AM		 3472static struct elf_segment_map *
3473make_mapping (bfd *abfd,
3474 asection **sections,
3475 unsigned int from,
3476 unsigned int to,
3477 bfd_boolean phdr)
252b5132
RH		 3478{
3479 struct elf_segment_map *m;
3480 unsigned int i;
3481 asection **hdrpp;
dc810e39 3482 bfd_size_type amt;
252b5132 3483
dc810e39
AM		 3484 amt = sizeof (struct elf_segment_map);
3485 amt += (to - from - 1) * sizeof (asection *);
217aa764 3486 m = bfd_zalloc (abfd, amt);
252b5132
RH		 3487 if (m == NULL)
3488 return NULL;
3489 m->next = NULL;
3490 m->p_type = PT_LOAD;
3491 for (i = from, hdrpp = sections + from; i < to; i++, hdrpp++)
3492 m->sections[i - from] = *hdrpp;
3493 m->count = to - from;
3494
3495 if (from == 0 && phdr)
3496 {
3497 /* Include the headers in the first PT_LOAD segment. */
3498 m->includes_filehdr = 1;
3499 m->includes_phdrs = 1;
3500 }
3501
3502 return m;
3503}
3504
229fcec5
MM		 3505/* Create the PT_DYNAMIC segment, which includes DYNSEC. Returns NULL
3506 on failure. */
3507
3508struct elf_segment_map *
3509_bfd_elf_make_dynamic_segment (bfd *abfd, asection *dynsec)
3510{
3511 struct elf_segment_map *m;
3512
3513 m = bfd_zalloc (abfd, sizeof (struct elf_segment_map));
3514 if (m == NULL)
3515 return NULL;
3516 m->next = NULL;
3517 m->p_type = PT_DYNAMIC;
3518 m->count = 1;
3519 m->sections[0] = dynsec;
08a40648 3520
229fcec5
MM		 3521 return m;
3522}
3523
8ded5a0f 3524/* Possibly add or remove segments from the segment map. */
252b5132 3525
b34976b6 3526static bfd_boolean
3dea8fca
AM		 3527elf_modify_segment_map (bfd *abfd,
3528 struct bfd_link_info *info,
3529 bfd_boolean remove_empty_load)
252b5132 3530{
252e386e 3531 struct elf_segment_map **m;
8ded5a0f 3532 const struct elf_backend_data *bed;
252b5132 3533
8ded5a0f
AM		 3534 /* The placement algorithm assumes that non allocated sections are
3535 not in PT_LOAD segments. We ensure this here by removing such
3536 sections from the segment map. We also remove excluded
252e386e
AM		 3537 sections. Finally, any PT_LOAD segment without sections is
3538 removed. */
3539 m = &elf_tdata (abfd)->segment_map;
3540 while (*m)
8ded5a0f
AM		 3541 {
3542 unsigned int i, new_count;
252b5132 3543
252e386e 3544 for (new_count = 0, i = 0; i < (*m)->count; i++)
8ded5a0f 3545 {
252e386e
AM		 3546 if (((*m)->sections[i]->flags & SEC_EXCLUDE) == 0
3547 && (((*m)->sections[i]->flags & SEC_ALLOC) != 0
3548 || (*m)->p_type != PT_LOAD))
8ded5a0f 3549 {
252e386e
AM		 3550 (*m)->sections[new_count] = (*m)->sections[i];
3551 new_count++;
8ded5a0f
AM		 3552 }
3553 }
252e386e 3554 (*m)->count = new_count;
252b5132 3555
3dea8fca 3556 if (remove_empty_load && (*m)->p_type == PT_LOAD && (*m)->count == 0)
252e386e
AM		 3557 *m = (*m)->next;
3558 else
3559 m = &(*m)->next;
8ded5a0f 3560 }
252b5132 3561
8ded5a0f
AM		 3562 bed = get_elf_backend_data (abfd);
3563 if (bed->elf_backend_modify_segment_map != NULL)
252b5132 3564 {
252e386e 3565 if (!(*bed->elf_backend_modify_segment_map) (abfd, info))
8ded5a0f 3566 return FALSE;
252b5132 3567 }
252b5132 3568
8ded5a0f
AM		 3569 return TRUE;
3570}
252b5132 3571
8ded5a0f 3572/* Set up a mapping from BFD sections to program segments. */
252b5132 3573
8ded5a0f
AM		 3574bfd_boolean
3575_bfd_elf_map_sections_to_segments (bfd *abfd, struct bfd_link_info *info)
3576{
3577 unsigned int count;
3578 struct elf_segment_map *m;
3579 asection **sections = NULL;
3580 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3dea8fca 3581 bfd_boolean no_user_phdrs;
252b5132 3582
3dea8fca
AM		 3583 no_user_phdrs = elf_tdata (abfd)->segment_map == NULL;
3584 if (no_user_phdrs && bfd_count_sections (abfd) != 0)
252b5132 3585 {
8ded5a0f
AM		 3586 asection *s;
3587 unsigned int i;
3588 struct elf_segment_map *mfirst;
3589 struct elf_segment_map **pm;
3590 asection *last_hdr;
3591 bfd_vma last_size;
3592 unsigned int phdr_index;
3593 bfd_vma maxpagesize;
3594 asection **hdrpp;
3595 bfd_boolean phdr_in_segment = TRUE;
3596 bfd_boolean writable;
3597 int tls_count = 0;
3598 asection *first_tls = NULL;
3599 asection *dynsec, *eh_frame_hdr;
3600 bfd_size_type amt;
252b5132 3601
8ded5a0f 3602 /* Select the allocated sections, and sort them. */
252b5132 3603
8ded5a0f
AM		 3604 sections = bfd_malloc2 (bfd_count_sections (abfd), sizeof (asection *));
3605 if (sections == NULL)
252b5132 3606 goto error_return;
252b5132 3607
8ded5a0f
AM		 3608 i = 0;
3609 for (s = abfd->sections; s != NULL; s = s->next)
3610 {
3611 if ((s->flags & SEC_ALLOC) != 0)
3612 {
3613 sections[i] = s;
3614 ++i;
3615 }
3616 }
3617 BFD_ASSERT (i <= bfd_count_sections (abfd));
3618 count = i;
252b5132 3619
8ded5a0f 3620 qsort (sections, (size_t) count, sizeof (asection *), elf_sort_sections);
252b5132 3621
8ded5a0f 3622 /* Build the mapping. */
252b5132 3623
8ded5a0f
AM		 3624 mfirst = NULL;
3625 pm = &mfirst;
252b5132 3626
8ded5a0f
AM		 3627 /* If we have a .interp section, then create a PT_PHDR segment for
3628 the program headers and a PT_INTERP segment for the .interp
3629 section. */
3630 s = bfd_get_section_by_name (abfd, ".interp");
3631 if (s != NULL && (s->flags & SEC_LOAD) != 0)
3632 {
3633 amt = sizeof (struct elf_segment_map);
3634 m = bfd_zalloc (abfd, amt);
3635 if (m == NULL)
3636 goto error_return;
3637 m->next = NULL;
3638 m->p_type = PT_PHDR;
3639 /* FIXME: UnixWare and Solaris set PF_X, Irix 5 does not. */
3640 m->p_flags = PF_R | PF_X;
3641 m->p_flags_valid = 1;
3642 m->includes_phdrs = 1;
252b5132 3643
8ded5a0f
AM		 3644 *pm = m;
3645 pm = &m->next;
252b5132 3646
8ded5a0f
AM		 3647 amt = sizeof (struct elf_segment_map);
3648 m = bfd_zalloc (abfd, amt);
3649 if (m == NULL)
3650 goto error_return;
3651 m->next = NULL;
3652 m->p_type = PT_INTERP;
3653 m->count = 1;
3654 m->sections[0] = s;
3655
3656 *pm = m;
3657 pm = &m->next;
252b5132 3658 }
8ded5a0f
AM		 3659
3660 /* Look through the sections. We put sections in the same program
3661 segment when the start of the second section can be placed within
3662 a few bytes of the end of the first section. */
3663 last_hdr = NULL;
3664 last_size = 0;
3665 phdr_index = 0;
3666 maxpagesize = bed->maxpagesize;
3667 writable = FALSE;
3668 dynsec = bfd_get_section_by_name (abfd, ".dynamic");
3669 if (dynsec != NULL
3670 && (dynsec->flags & SEC_LOAD) == 0)
3671 dynsec = NULL;
3672
3673 /* Deal with -Ttext or something similar such that the first section
3674 is not adjacent to the program headers. This is an
3675 approximation, since at this point we don't know exactly how many
3676 program headers we will need. */
3677 if (count > 0)
252b5132 3678 {
8ded5a0f
AM		 3679 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
3680
62d7a5f6 3681 if (phdr_size == (bfd_size_type) -1)
8ded5a0f
AM		 3682 phdr_size = get_program_header_size (abfd, info);
3683 if ((abfd->flags & D_PAGED) == 0
3684 || sections[0]->lma < phdr_size
3685 || sections[0]->lma % maxpagesize < phdr_size % maxpagesize)
3686 phdr_in_segment = FALSE;
252b5132
RH		 3687 }
3688
8ded5a0f 3689 for (i = 0, hdrpp = sections; i < count; i++, hdrpp++)
252b5132 3690 {
8ded5a0f
AM		 3691 asection *hdr;
3692 bfd_boolean new_segment;
3693
3694 hdr = *hdrpp;
3695
3696 /* See if this section and the last one will fit in the same
3697 segment. */
3698
3699 if (last_hdr == NULL)
3700 {
3701 /* If we don't have a segment yet, then we don't need a new
3702 one (we build the last one after this loop). */
3703 new_segment = FALSE;
3704 }
3705 else if (last_hdr->lma - last_hdr->vma != hdr->lma - hdr->vma)
3706 {
3707 /* If this section has a different relation between the
3708 virtual address and the load address, then we need a new
3709 segment. */
3710 new_segment = TRUE;
3711 }
39948a60
NC		 3712 /* In the next test we have to be careful when last_hdr->lma is close
3713 to the end of the address space. If the aligned address wraps
3714 around to the start of the address space, then there are no more
3715 pages left in memory and it is OK to assume that the current
3716 section can be included in the current segment. */
3717 else if ((BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
3718 > last_hdr->lma)
3719 && (BFD_ALIGN (last_hdr->lma + last_size, maxpagesize) + maxpagesize
4ff73856 3720 <= hdr->lma))
8ded5a0f
AM		 3721 {
3722 /* If putting this section in this segment would force us to
3723 skip a page in the segment, then we need a new segment. */
3724 new_segment = TRUE;
3725 }
3726 else if ((last_hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0
3727 && (hdr->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) != 0)
3728 {
3729 /* We don't want to put a loadable section after a
3730 nonloadable section in the same segment.
3731 Consider .tbss sections as loadable for this purpose. */
3732 new_segment = TRUE;
3733 }
3734 else if ((abfd->flags & D_PAGED) == 0)
3735 {
3736 /* If the file is not demand paged, which means that we
3737 don't require the sections to be correctly aligned in the
3738 file, then there is no other reason for a new segment. */
3739 new_segment = FALSE;
3740 }
3741 else if (! writable
3742 && (hdr->flags & SEC_READONLY) == 0
3743 && (((last_hdr->lma + last_size - 1)
3744 & ~(maxpagesize - 1))
3745 != (hdr->lma & ~(maxpagesize - 1))))
3746 {
3747 /* We don't want to put a writable section in a read only
3748 segment, unless they are on the same page in memory
3749 anyhow. We already know that the last section does not
3750 bring us past the current section on the page, so the
3751 only case in which the new section is not on the same
3752 page as the previous section is when the previous section
3753 ends precisely on a page boundary. */
3754 new_segment = TRUE;
3755 }
3756 else
3757 {
3758 /* Otherwise, we can use the same segment. */
3759 new_segment = FALSE;
3760 }
3761
2889e75b 3762 /* Allow interested parties a chance to override our decision. */
ceae84aa
AM		 3763 if (last_hdr != NULL
3764 && info != NULL
3765 && info->callbacks->override_segment_assignment != NULL)
3766 new_segment
3767 = info->callbacks->override_segment_assignment (info, abfd, hdr,
3768 last_hdr,
3769 new_segment);
2889e75b 3770
8ded5a0f
AM		 3771 if (! new_segment)
3772 {
3773 if ((hdr->flags & SEC_READONLY) == 0)
3774 writable = TRUE;
3775 last_hdr = hdr;
3776 /* .tbss sections effectively have zero size. */
3777 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD))
3778 != SEC_THREAD_LOCAL)
3779 last_size = hdr->size;
3780 else
3781 last_size = 0;
3782 continue;
3783 }
3784
3785 /* We need a new program segment. We must create a new program
3786 header holding all the sections from phdr_index until hdr. */
3787
3788 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3789 if (m == NULL)
3790 goto error_return;
3791
3792 *pm = m;
3793 pm = &m->next;
3794
252b5132 3795 if ((hdr->flags & SEC_READONLY) == 0)
b34976b6 3796 writable = TRUE;
8ded5a0f
AM		 3797 else
3798 writable = FALSE;
3799
baaff79e
JJ		 3800 last_hdr = hdr;
3801 /* .tbss sections effectively have zero size. */
e5caec89 3802 if ((hdr->flags & (SEC_THREAD_LOCAL | SEC_LOAD)) != SEC_THREAD_LOCAL)
eea6121a 3803 last_size = hdr->size;
baaff79e
JJ		 3804 else
3805 last_size = 0;
8ded5a0f
AM		 3806 phdr_index = i;
3807 phdr_in_segment = FALSE;
252b5132
RH		 3808 }
3809
8ded5a0f
AM		 3810 /* Create a final PT_LOAD program segment. */
3811 if (last_hdr != NULL)
3812 {
3813 m = make_mapping (abfd, sections, phdr_index, i, phdr_in_segment);
3814 if (m == NULL)
3815 goto error_return;
252b5132 3816
8ded5a0f
AM		 3817 *pm = m;
3818 pm = &m->next;
3819 }
252b5132 3820
8ded5a0f
AM		 3821 /* If there is a .dynamic section, throw in a PT_DYNAMIC segment. */
3822 if (dynsec != NULL)
3823 {
3824 m = _bfd_elf_make_dynamic_segment (abfd, dynsec);
3825 if (m == NULL)
3826 goto error_return;
3827 *pm = m;
3828 pm = &m->next;
3829 }
252b5132 3830
1c5265b5
JJ		 3831 /* For each batch of consecutive loadable .note sections,
3832 add a PT_NOTE segment. We don't use bfd_get_section_by_name,
3833 because if we link together nonloadable .note sections and
3834 loadable .note sections, we will generate two .note sections
3835 in the output file. FIXME: Using names for section types is
3836 bogus anyhow. */
8ded5a0f
AM		 3837 for (s = abfd->sections; s != NULL; s = s->next)
3838 {
3839 if ((s->flags & SEC_LOAD) != 0
0112cd26 3840 && CONST_STRNEQ (s->name, ".note"))
8ded5a0f 3841 {
1c5265b5
JJ		 3842 asection *s2;
3843 unsigned count = 1;
8ded5a0f 3844 amt = sizeof (struct elf_segment_map);
1c5265b5
JJ		 3845 if (s->alignment_power == 2)
3846 for (s2 = s; s2->next != NULL; s2 = s2->next)
55b581a6
JJ		 3847 {
3848 if (s2->next->alignment_power == 2
3849 && (s2->next->flags & SEC_LOAD) != 0
3850 && CONST_STRNEQ (s2->next->name, ".note")
3851 && align_power (s2->vma + s2->size, 2)
3852 == s2->next->vma)
3853 count++;
3854 else
3855 break;
3856 }
1c5265b5 3857 amt += (count - 1) * sizeof (asection *);
8ded5a0f
AM		 3858 m = bfd_zalloc (abfd, amt);
3859 if (m == NULL)
3860 goto error_return;
3861 m->next = NULL;
3862 m->p_type = PT_NOTE;
1c5265b5
JJ		 3863 m->count = count;
3864 while (count > 1)
3865 {
3866 m->sections[m->count - count--] = s;
3867 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
3868 s = s->next;
3869 }
3870 m->sections[m->count - 1] = s;
3871 BFD_ASSERT ((s->flags & SEC_THREAD_LOCAL) == 0);
8ded5a0f
AM		 3872 *pm = m;
3873 pm = &m->next;
3874 }
3875 if (s->flags & SEC_THREAD_LOCAL)
3876 {
3877 if (! tls_count)
3878 first_tls = s;
3879 tls_count++;
3880 }
3881 }
252b5132 3882
8ded5a0f
AM		 3883 /* If there are any SHF_TLS output sections, add PT_TLS segment. */
3884 if (tls_count > 0)
3885 {
3886 int i;
252b5132 3887
8ded5a0f
AM		 3888 amt = sizeof (struct elf_segment_map);
3889 amt += (tls_count - 1) * sizeof (asection *);
3890 m = bfd_zalloc (abfd, amt);
3891 if (m == NULL)
3892 goto error_return;
3893 m->next = NULL;
3894 m->p_type = PT_TLS;
3895 m->count = tls_count;
3896 /* Mandated PF_R. */
3897 m->p_flags = PF_R;
3898 m->p_flags_valid = 1;
3899 for (i = 0; i < tls_count; ++i)
3900 {
3901 BFD_ASSERT (first_tls->flags & SEC_THREAD_LOCAL);
3902 m->sections[i] = first_tls;
3903 first_tls = first_tls->next;
3904 }
252b5132 3905
8ded5a0f
AM		 3906 *pm = m;
3907 pm = &m->next;
3908 }
252b5132 3909
8ded5a0f
AM		 3910 /* If there is a .eh_frame_hdr section, throw in a PT_GNU_EH_FRAME
3911 segment. */
3912 eh_frame_hdr = elf_tdata (abfd)->eh_frame_hdr;
3913 if (eh_frame_hdr != NULL
3914 && (eh_frame_hdr->output_section->flags & SEC_LOAD) != 0)
252b5132 3915 {
dc810e39 3916 amt = sizeof (struct elf_segment_map);
217aa764 3917 m = bfd_zalloc (abfd, amt);
252b5132
RH		 3918 if (m == NULL)
3919 goto error_return;
3920 m->next = NULL;
8ded5a0f 3921 m->p_type = PT_GNU_EH_FRAME;
252b5132 3922 m->count = 1;
8ded5a0f 3923 m->sections[0] = eh_frame_hdr->output_section;
252b5132
RH		 3924
3925 *pm = m;
3926 pm = &m->next;
3927 }
13ae64f3 3928
8ded5a0f 3929 if (elf_tdata (abfd)->stack_flags)
13ae64f3 3930 {
8ded5a0f
AM		 3931 amt = sizeof (struct elf_segment_map);
3932 m = bfd_zalloc (abfd, amt);
3933 if (m == NULL)
3934 goto error_return;
3935 m->next = NULL;
2b05f1b7 3936 m->p_type = PT_GNU_STACK;
8ded5a0f
AM		 3937 m->p_flags = elf_tdata (abfd)->stack_flags;
3938 m->p_flags_valid = 1;
252b5132 3939
8ded5a0f
AM		 3940 *pm = m;
3941 pm = &m->next;
3942 }
65765700 3943
ceae84aa 3944 if (info != NULL && info->relro)
8ded5a0f 3945 {
f210dcff
L		 3946 for (m = mfirst; m != NULL; m = m->next)
3947 {
3948 if (m->p_type == PT_LOAD)
3949 {
3950 asection *last = m->sections[m->count - 1];
3951 bfd_vma vaddr = m->sections[0]->vma;
3952 bfd_vma filesz = last->vma - vaddr + last->size;
65765700 3953
f210dcff
L		 3954 if (vaddr < info->relro_end
3955 && vaddr >= info->relro_start
3956 && (vaddr + filesz) >= info->relro_end)
3957 break;
3958 }
3959 }
3960
3961 /* Make a PT_GNU_RELRO segment only when it isn't empty. */
3962 if (m != NULL)
3963 {
3964 amt = sizeof (struct elf_segment_map);
3965 m = bfd_zalloc (abfd, amt);
3966 if (m == NULL)
3967 goto error_return;
3968 m->next = NULL;
3969 m->p_type = PT_GNU_RELRO;
3970 m->p_flags = PF_R;
3971 m->p_flags_valid = 1;
3972
3973 *pm = m;
3974 pm = &m->next;
3975 }
8ded5a0f 3976 }
9ee5e499 3977
8ded5a0f
AM		 3978 free (sections);
3979 elf_tdata (abfd)->segment_map = mfirst;
9ee5e499
JJ		 3980 }
3981
3dea8fca 3982 if (!elf_modify_segment_map (abfd, info, no_user_phdrs))
8ded5a0f 3983 return FALSE;
8c37241b 3984
8ded5a0f
AM		 3985 for (count = 0, m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
3986 ++count;
3987 elf_tdata (abfd)->program_header_size = count * bed->s->sizeof_phdr;
252b5132 3988
b34976b6 3989 return TRUE;
252b5132
RH		 3990
3991 error_return:
3992 if (sections != NULL)
3993 free (sections);
b34976b6 3994 return FALSE;
252b5132
RH		 3995}
3996
3997/* Sort sections by address. */
3998
3999static int
217aa764 4000elf_sort_sections (const void *arg1, const void *arg2)
252b5132
RH		 4001{
4002 const asection *sec1 = *(const asection **) arg1;
4003 const asection *sec2 = *(const asection **) arg2;
eecdbe52 4004 bfd_size_type size1, size2;
252b5132
RH		 4005
4006 /* Sort by LMA first, since this is the address used to
4007 place the section into a segment. */
4008 if (sec1->lma < sec2->lma)
4009 return -1;
4010 else if (sec1->lma > sec2->lma)
4011 return 1;
4012
4013 /* Then sort by VMA. Normally the LMA and the VMA will be
4014 the same, and this will do nothing. */
4015 if (sec1->vma < sec2->vma)
4016 return -1;
4017 else if (sec1->vma > sec2->vma)
4018 return 1;
4019
4020 /* Put !SEC_LOAD sections after SEC_LOAD ones. */
4021
07c6e936 4022#define TOEND(x) (((x)->flags & (SEC_LOAD | SEC_THREAD_LOCAL)) == 0)
252b5132
RH		 4023
4024 if (TOEND (sec1))
4025 {
4026 if (TOEND (sec2))
00a7cdc5
NC		 4027 {
4028 /* If the indicies are the same, do not return 0
4029 here, but continue to try the next comparison. */
4030 if (sec1->target_index - sec2->target_index != 0)
4031 return sec1->target_index - sec2->target_index;
4032 }
252b5132
RH		 4033 else
4034 return 1;
4035 }
00a7cdc5 4036 else if (TOEND (sec2))
252b5132
RH		 4037 return -1;
4038
4039#undef TOEND
4040
00a7cdc5
NC		 4041 /* Sort by size, to put zero sized sections
4042 before others at the same address. */
252b5132 4043
eea6121a
AM		 4044 size1 = (sec1->flags & SEC_LOAD) ? sec1->size : 0;
4045 size2 = (sec2->flags & SEC_LOAD) ? sec2->size : 0;
eecdbe52
JJ		 4046
4047 if (size1 < size2)
252b5132 4048 return -1;
eecdbe52 4049 if (size1 > size2)
252b5132
RH		 4050 return 1;
4051
4052 return sec1->target_index - sec2->target_index;
4053}
4054
340b6d91
AC		 4055/* Ian Lance Taylor writes:
4056
4057 We shouldn't be using % with a negative signed number. That's just
4058 not good. We have to make sure either that the number is not
4059 negative, or that the number has an unsigned type. When the types
4060 are all the same size they wind up as unsigned. When file_ptr is a
4061 larger signed type, the arithmetic winds up as signed long long,
4062 which is wrong.
4063
4064 What we're trying to say here is something like ``increase OFF by
4065 the least amount that will cause it to be equal to the VMA modulo
4066 the page size.'' */
4067/* In other words, something like:
4068
4069 vma_offset = m->sections[0]->vma % bed->maxpagesize;
4070 off_offset = off % bed->maxpagesize;
4071 if (vma_offset < off_offset)
4072 adjustment = vma_offset + bed->maxpagesize - off_offset;
4073 else
4074 adjustment = vma_offset - off_offset;
08a40648 4075
340b6d91
AC		 4076 which can can be collapsed into the expression below. */
4077
4078static file_ptr
4079vma_page_aligned_bias (bfd_vma vma, ufile_ptr off, bfd_vma maxpagesize)
4080{
4081 return ((vma - off) % maxpagesize);
4082}
4083
6d33f217
L		 4084static void
4085print_segment_map (const struct elf_segment_map *m)
4086{
4087 unsigned int j;
4088 const char *pt = get_segment_type (m->p_type);
4089 char buf[32];
4090
4091 if (pt == NULL)
4092 {
4093 if (m->p_type >= PT_LOPROC && m->p_type <= PT_HIPROC)
4094 sprintf (buf, "LOPROC+%7.7x",
4095 (unsigned int) (m->p_type - PT_LOPROC));
4096 else if (m->p_type >= PT_LOOS && m->p_type <= PT_HIOS)
4097 sprintf (buf, "LOOS+%7.7x",
4098 (unsigned int) (m->p_type - PT_LOOS));
4099 else
4100 snprintf (buf, sizeof (buf), "%8.8x",
4101 (unsigned int) m->p_type);
4102 pt = buf;
4103 }
4104 fprintf (stderr, "%s:", pt);
4105 for (j = 0; j < m->count; j++)
4106 fprintf (stderr, " %s", m->sections [j]->name);
4107 putc ('\n',stderr);
4108}
4109
252b5132
RH		 4110/* Assign file positions to the sections based on the mapping from
4111 sections to segments. This function also sets up some fields in
f3520d2f 4112 the file header. */
252b5132 4113
b34976b6 4114static bfd_boolean
f3520d2f
AM		 4115assign_file_positions_for_load_sections (bfd *abfd,
4116 struct bfd_link_info *link_info)
252b5132
RH		 4117{
4118 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 4119 struct elf_segment_map *m;
252b5132 4120 Elf_Internal_Phdr *phdrs;
252b5132 4121 Elf_Internal_Phdr *p;
02bf8d82 4122 file_ptr off;
3f570048 4123 bfd_size_type maxpagesize;
f3520d2f 4124 unsigned int alloc;
0920dee7 4125 unsigned int i, j;
2b0bc088 4126 bfd_vma header_pad = 0;
252b5132 4127
e36284ab 4128 if (link_info == NULL
ceae84aa 4129 && !_bfd_elf_map_sections_to_segments (abfd, link_info))
8ded5a0f 4130 return FALSE;
252b5132 4131
8ded5a0f 4132 alloc = 0;
252b5132 4133 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
2b0bc088
NC		 4134 {
4135 ++alloc;
4136 if (m->header_size)
4137 header_pad = m->header_size;
4138 }
252b5132
RH		 4139
4140 elf_elfheader (abfd)->e_phoff = bed->s->sizeof_ehdr;
4141 elf_elfheader (abfd)->e_phentsize = bed->s->sizeof_phdr;
8ded5a0f 4142 elf_elfheader (abfd)->e_phnum = alloc;
252b5132 4143
62d7a5f6 4144 if (elf_tdata (abfd)->program_header_size == (bfd_size_type) -1)
8ded5a0f
AM		 4145 elf_tdata (abfd)->program_header_size = alloc * bed->s->sizeof_phdr;
4146 else
4147 BFD_ASSERT (elf_tdata (abfd)->program_header_size
59e0647f 4148 >= alloc * bed->s->sizeof_phdr);
252b5132
RH		 4149
4150 if (alloc == 0)
f3520d2f 4151 {
8ded5a0f
AM		 4152 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
4153 return TRUE;
f3520d2f 4154 }
252b5132 4155
57268894
HPN		 4156 /* We're writing the size in elf_tdata (abfd)->program_header_size,
4157 see assign_file_positions_except_relocs, so make sure we have
4158 that amount allocated, with trailing space cleared.
4159 The variable alloc contains the computed need, while elf_tdata
4160 (abfd)->program_header_size contains the size used for the
4161 layout.
4162 See ld/emultempl/elf-generic.em:gld${EMULATION_NAME}_map_segments
4163 where the layout is forced to according to a larger size in the
4164 last iterations for the testcase ld-elf/header. */
4165 BFD_ASSERT (elf_tdata (abfd)->program_header_size % bed->s->sizeof_phdr
4166 == 0);
4167 phdrs = bfd_zalloc2 (abfd,
4168 (elf_tdata (abfd)->program_header_size
4169 / bed->s->sizeof_phdr),
4170 sizeof (Elf_Internal_Phdr));
f3520d2f 4171 elf_tdata (abfd)->phdr = phdrs;
252b5132 4172 if (phdrs == NULL)
b34976b6 4173 return FALSE;
252b5132 4174
3f570048
AM		 4175 maxpagesize = 1;
4176 if ((abfd->flags & D_PAGED) != 0)
4177 maxpagesize = bed->maxpagesize;
4178
252b5132
RH		 4179 off = bed->s->sizeof_ehdr;
4180 off += alloc * bed->s->sizeof_phdr;
2b0bc088
NC		 4181 if (header_pad < (bfd_vma) off)
4182 header_pad = 0;
4183 else
4184 header_pad -= off;
4185 off += header_pad;
252b5132 4186
0920dee7 4187 for (m = elf_tdata (abfd)->segment_map, p = phdrs, j = 0;
252b5132 4188 m != NULL;
0920dee7 4189 m = m->next, p++, j++)
252b5132 4190 {
252b5132 4191 asection **secpp;
bf988460
AM		 4192 bfd_vma off_adjust;
4193 bfd_boolean no_contents;
252b5132
RH		 4194
4195 /* If elf_segment_map is not from map_sections_to_segments, the
08a40648 4196 sections may not be correctly ordered. NOTE: sorting should
52e9b619
MS		 4197 not be done to the PT_NOTE section of a corefile, which may
4198 contain several pseudo-sections artificially created by bfd.
4199 Sorting these pseudo-sections breaks things badly. */
47d9a591
AM		 4200 if (m->count > 1
4201 && !(elf_elfheader (abfd)->e_type == ET_CORE
52e9b619 4202 && m->p_type == PT_NOTE))
252b5132
RH		 4203 qsort (m->sections, (size_t) m->count, sizeof (asection *),
4204 elf_sort_sections);
4205
b301b248
AM		 4206 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
4207 number of sections with contents contributing to both p_filesz
4208 and p_memsz, followed by a number of sections with no contents
4209 that just contribute to p_memsz. In this loop, OFF tracks next
02bf8d82 4210 available file offset for PT_LOAD and PT_NOTE segments. */
252b5132 4211 p->p_type = m->p_type;
28a7f3e7 4212 p->p_flags = m->p_flags;
252b5132 4213
3f570048
AM		 4214 if (m->count == 0)
4215 p->p_vaddr = 0;
4216 else
3271a814 4217 p->p_vaddr = m->sections[0]->vma - m->p_vaddr_offset;
3f570048
AM		 4218
4219 if (m->p_paddr_valid)
4220 p->p_paddr = m->p_paddr;
4221 else if (m->count == 0)
4222 p->p_paddr = 0;
4223 else
08a40648 4224 p->p_paddr = m->sections[0]->lma - m->p_vaddr_offset;
3f570048
AM		 4225
4226 if (p->p_type == PT_LOAD
4227 && (abfd->flags & D_PAGED) != 0)
4228 {
4229 /* p_align in demand paged PT_LOAD segments effectively stores
4230 the maximum page size. When copying an executable with
4231 objcopy, we set m->p_align from the input file. Use this
4232 value for maxpagesize rather than bed->maxpagesize, which
4233 may be different. Note that we use maxpagesize for PT_TLS
4234 segment alignment later in this function, so we are relying
4235 on at least one PT_LOAD segment appearing before a PT_TLS
4236 segment. */
4237 if (m->p_align_valid)
4238 maxpagesize = m->p_align;
4239
4240 p->p_align = maxpagesize;
4241 }
3271a814
NS		 4242 else if (m->p_align_valid)
4243 p->p_align = m->p_align;
e970b90a
DJ		 4244 else if (m->count == 0)
4245 p->p_align = 1 << bed->s->log_file_align;
3f570048
AM		 4246 else
4247 p->p_align = 0;
4248
bf988460
AM		 4249 no_contents = FALSE;
4250 off_adjust = 0;
252b5132 4251 if (p->p_type == PT_LOAD
b301b248 4252 && m->count > 0)
252b5132 4253 {
b301b248 4254 bfd_size_type align;
a49e53ed 4255 unsigned int align_power = 0;
b301b248 4256
3271a814
NS		 4257 if (m->p_align_valid)
4258 align = p->p_align;
4259 else
252b5132 4260 {
3271a814
NS		 4261 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4262 {
4263 unsigned int secalign;
08a40648 4264
3271a814
NS		 4265 secalign = bfd_get_section_alignment (abfd, *secpp);
4266 if (secalign > align_power)
4267 align_power = secalign;
4268 }
4269 align = (bfd_size_type) 1 << align_power;
4270 if (align < maxpagesize)
4271 align = maxpagesize;
b301b248 4272 }
252b5132 4273
02bf8d82
AM		 4274 for (i = 0; i < m->count; i++)
4275 if ((m->sections[i]->flags & (SEC_LOAD | SEC_HAS_CONTENTS)) == 0)
4276 /* If we aren't making room for this section, then
4277 it must be SHT_NOBITS regardless of what we've
4278 set via struct bfd_elf_special_section. */
4279 elf_section_type (m->sections[i]) = SHT_NOBITS;
4280
bf988460 4281 /* Find out whether this segment contains any loadable
aea274d3
AM		 4282 sections. */
4283 no_contents = TRUE;
4284 for (i = 0; i < m->count; i++)
4285 if (elf_section_type (m->sections[i]) != SHT_NOBITS)
4286 {
4287 no_contents = FALSE;
4288 break;
4289 }
bf988460
AM		 4290
4291 off_adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
4292 off += off_adjust;
4293 if (no_contents)
4294 {
4295 /* We shouldn't need to align the segment on disk since
4296 the segment doesn't need file space, but the gABI
4297 arguably requires the alignment and glibc ld.so
4298 checks it. So to comply with the alignment
4299 requirement but not waste file space, we adjust
4300 p_offset for just this segment. (OFF_ADJUST is
4301 subtracted from OFF later.) This may put p_offset
4302 past the end of file, but that shouldn't matter. */
4303 }
4304 else
4305 off_adjust = 0;
252b5132 4306 }
b1a6d0b1
NC		 4307 /* Make sure the .dynamic section is the first section in the
4308 PT_DYNAMIC segment. */
4309 else if (p->p_type == PT_DYNAMIC
4310 && m->count > 1
4311 && strcmp (m->sections[0]->name, ".dynamic") != 0)
4312 {
4313 _bfd_error_handler
b301b248
AM		 4314 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
4315 abfd);
b1a6d0b1
NC		 4316 bfd_set_error (bfd_error_bad_value);
4317 return FALSE;
4318 }
3f001e84
JK		 4319 /* Set the note section type to SHT_NOTE. */
4320 else if (p->p_type == PT_NOTE)
4321 for (i = 0; i < m->count; i++)
4322 elf_section_type (m->sections[i]) = SHT_NOTE;
252b5132 4323
252b5132
RH		 4324 p->p_offset = 0;
4325 p->p_filesz = 0;
4326 p->p_memsz = 0;
4327
4328 if (m->includes_filehdr)
4329 {
bf988460 4330 if (!m->p_flags_valid)
252b5132 4331 p->p_flags |= PF_R;
252b5132
RH		 4332 p->p_filesz = bed->s->sizeof_ehdr;
4333 p->p_memsz = bed->s->sizeof_ehdr;
4334 if (m->count > 0)
4335 {
4336 BFD_ASSERT (p->p_type == PT_LOAD);
4337
4338 if (p->p_vaddr < (bfd_vma) off)
4339 {
caf47ea6 4340 (*_bfd_error_handler)
b301b248
AM		 4341 (_("%B: Not enough room for program headers, try linking with -N"),
4342 abfd);
252b5132 4343 bfd_set_error (bfd_error_bad_value);
b34976b6 4344 return FALSE;
252b5132
RH		 4345 }
4346
4347 p->p_vaddr -= off;
bf988460 4348 if (!m->p_paddr_valid)
252b5132
RH		 4349 p->p_paddr -= off;
4350 }
252b5132
RH		 4351 }
4352
4353 if (m->includes_phdrs)
4354 {
bf988460 4355 if (!m->p_flags_valid)
252b5132
RH		 4356 p->p_flags |= PF_R;
4357
f3520d2f 4358 if (!m->includes_filehdr)
252b5132
RH		 4359 {
4360 p->p_offset = bed->s->sizeof_ehdr;
4361
4362 if (m->count > 0)
4363 {
4364 BFD_ASSERT (p->p_type == PT_LOAD);
4365 p->p_vaddr -= off - p->p_offset;
bf988460 4366 if (!m->p_paddr_valid)
252b5132
RH		 4367 p->p_paddr -= off - p->p_offset;
4368 }
252b5132
RH		 4369 }
4370
4371 p->p_filesz += alloc * bed->s->sizeof_phdr;
4372 p->p_memsz += alloc * bed->s->sizeof_phdr;
2b0bc088
NC		 4373 if (m->count)
4374 {
4375 p->p_filesz += header_pad;
4376 p->p_memsz += header_pad;
4377 }
252b5132
RH		 4378 }
4379
4380 if (p->p_type == PT_LOAD
4381 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4382 {
bf988460 4383 if (!m->includes_filehdr && !m->includes_phdrs)
02bf8d82 4384 p->p_offset = off;
252b5132
RH		 4385 else
4386 {
4387 file_ptr adjust;
4388
4389 adjust = off - (p->p_offset + p->p_filesz);
bf988460
AM		 4390 if (!no_contents)
4391 p->p_filesz += adjust;
252b5132
RH		 4392 p->p_memsz += adjust;
4393 }
4394 }
4395
1ea63fd2
AM		 4396 /* Set up p_filesz, p_memsz, p_align and p_flags from the section
4397 maps. Set filepos for sections in PT_LOAD segments, and in
4398 core files, for sections in PT_NOTE segments.
4399 assign_file_positions_for_non_load_sections will set filepos
4400 for other sections and update p_filesz for other segments. */
252b5132
RH		 4401 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4402 {
4403 asection *sec;
252b5132 4404 bfd_size_type align;
627b32bc 4405 Elf_Internal_Shdr *this_hdr;
252b5132
RH		 4406
4407 sec = *secpp;
02bf8d82 4408 this_hdr = &elf_section_data (sec)->this_hdr;
3f570048 4409 align = (bfd_size_type) 1 << bfd_get_section_alignment (abfd, sec);
252b5132 4410
88967714
AM		 4411 if ((p->p_type == PT_LOAD
4412 || p->p_type == PT_TLS)
4413 && (this_hdr->sh_type != SHT_NOBITS
4414 || ((this_hdr->sh_flags & SHF_ALLOC) != 0
4415 && ((this_hdr->sh_flags & SHF_TLS) == 0
4416 || p->p_type == PT_TLS))))
252b5132 4417 {
11701589 4418 bfd_signed_vma adjust = sec->vma - (p->p_vaddr + p->p_memsz);
252b5132 4419
88967714 4420 if (adjust < 0)
252b5132 4421 {
88967714 4422 (*_bfd_error_handler)
11701589 4423 (_("%B: section %A vma 0x%lx overlaps previous sections"),
37c43c55 4424 abfd, sec, (unsigned long) sec->vma);
88967714
AM		 4425 adjust = 0;
4426 }
4427 p->p_memsz += adjust;
0e922b77 4428
88967714
AM		 4429 if (this_hdr->sh_type != SHT_NOBITS)
4430 {
4431 off += adjust;
4432 p->p_filesz += adjust;
252b5132 4433 }
252b5132
RH		 4434 }
4435
4436 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4437 {
b301b248
AM		 4438 /* The section at i == 0 is the one that actually contains
4439 everything. */
4a938328
MS		 4440 if (i == 0)
4441 {
627b32bc 4442 this_hdr->sh_offset = sec->filepos = off;
6a3cd2b4
AM		 4443 off += this_hdr->sh_size;
4444 p->p_filesz = this_hdr->sh_size;
b301b248
AM		 4445 p->p_memsz = 0;
4446 p->p_align = 1;
252b5132 4447 }
4a938328 4448 else
252b5132 4449 {
b301b248 4450 /* The rest are fake sections that shouldn't be written. */
252b5132 4451 sec->filepos = 0;
eea6121a 4452 sec->size = 0;
b301b248
AM		 4453 sec->flags = 0;
4454 continue;
252b5132 4455 }
252b5132
RH		 4456 }
4457 else
4458 {
b301b248
AM		 4459 if (p->p_type == PT_LOAD)
4460 {
02bf8d82
AM		 4461 this_hdr->sh_offset = sec->filepos = off;
4462 if (this_hdr->sh_type != SHT_NOBITS)
6a3cd2b4 4463 off += this_hdr->sh_size;
b301b248 4464 }
252b5132 4465
02bf8d82 4466 if (this_hdr->sh_type != SHT_NOBITS)
b301b248 4467 {
6a3cd2b4 4468 p->p_filesz += this_hdr->sh_size;
02bf8d82
AM		 4469 /* A load section without SHF_ALLOC is something like
4470 a note section in a PT_NOTE segment. These take
4471 file space but are not loaded into memory. */
4472 if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
6a3cd2b4 4473 p->p_memsz += this_hdr->sh_size;
b301b248 4474 }
6a3cd2b4 4475 else if ((this_hdr->sh_flags & SHF_ALLOC) != 0)
13ae64f3 4476 {
6a3cd2b4
AM		 4477 if (p->p_type == PT_TLS)
4478 p->p_memsz += this_hdr->sh_size;
4479
4480 /* .tbss is special. It doesn't contribute to p_memsz of
4481 normal segments. */
4482 else if ((this_hdr->sh_flags & SHF_TLS) == 0)
4483 p->p_memsz += this_hdr->sh_size;
13ae64f3
JJ		 4484 }
4485
b10a8ae0
L		 4486 if (align > p->p_align
4487 && !m->p_align_valid
4488 && (p->p_type != PT_LOAD
4489 || (abfd->flags & D_PAGED) == 0))
252b5132
RH		 4490 p->p_align = align;
4491 }
4492
bf988460 4493 if (!m->p_flags_valid)
252b5132
RH		 4494 {
4495 p->p_flags |= PF_R;
02bf8d82 4496 if ((this_hdr->sh_flags & SHF_EXECINSTR) != 0)
252b5132 4497 p->p_flags |= PF_X;
02bf8d82 4498 if ((this_hdr->sh_flags & SHF_WRITE) != 0)
252b5132
RH		 4499 p->p_flags |= PF_W;
4500 }
4501 }
bf988460 4502 off -= off_adjust;
0920dee7 4503
7c928300
AM		 4504 /* Check that all sections are in a PT_LOAD segment.
4505 Don't check funky gdb generated core files. */
4506 if (p->p_type == PT_LOAD && bfd_get_format (abfd) != bfd_core)
0920dee7
L		 4507 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4508 {
4509 Elf_Internal_Shdr *this_hdr;
4510 asection *sec;
4511
4512 sec = *secpp;
4513 this_hdr = &(elf_section_data(sec)->this_hdr);
4514 if (this_hdr->sh_size != 0
4515 && !ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, p))
4516 {
4517 (*_bfd_error_handler)
4518 (_("%B: section `%A' can't be allocated in segment %d"),
4519 abfd, sec, j);
6d33f217 4520 print_segment_map (m);
0920dee7
L		 4521 bfd_set_error (bfd_error_bad_value);
4522 return FALSE;
4523 }
4524 }
252b5132
RH		 4525 }
4526
f3520d2f
AM		 4527 elf_tdata (abfd)->next_file_pos = off;
4528 return TRUE;
4529}
4530
4531/* Assign file positions for the other sections. */
4532
4533static bfd_boolean
4534assign_file_positions_for_non_load_sections (bfd *abfd,
4535 struct bfd_link_info *link_info)
4536{
4537 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4538 Elf_Internal_Shdr **i_shdrpp;
4539 Elf_Internal_Shdr **hdrpp;
4540 Elf_Internal_Phdr *phdrs;
4541 Elf_Internal_Phdr *p;
4542 struct elf_segment_map *m;
4543 bfd_vma filehdr_vaddr, filehdr_paddr;
4544 bfd_vma phdrs_vaddr, phdrs_paddr;
4545 file_ptr off;
4546 unsigned int num_sec;
4547 unsigned int i;
4548 unsigned int count;
4549
5c182d5f
AM		 4550 i_shdrpp = elf_elfsections (abfd);
4551 num_sec = elf_numsections (abfd);
f3520d2f 4552 off = elf_tdata (abfd)->next_file_pos;
5c182d5f
AM		 4553 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
4554 {
4555 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4556 Elf_Internal_Shdr *hdr;
4557
4558 hdr = *hdrpp;
4559 if (hdr->bfd_section != NULL
252e386e
AM		 4560 && (hdr->bfd_section->filepos != 0
4561 || (hdr->sh_type == SHT_NOBITS
4562 && hdr->contents == NULL)))
627b32bc 4563 BFD_ASSERT (hdr->sh_offset == hdr->bfd_section->filepos);
5c182d5f
AM		 4564 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4565 {
49c13adb
L		 4566 if (hdr->sh_size != 0)
4567 ((*_bfd_error_handler)
4568 (_("%B: warning: allocated section `%s' not in segment"),
3ba71138
L		 4569 abfd,
4570 (hdr->bfd_section == NULL
4571 ? "*unknown*"
4572 : hdr->bfd_section->name)));
4573 /* We don't need to page align empty sections. */
4574 if ((abfd->flags & D_PAGED) != 0 && hdr->sh_size != 0)
5c182d5f
AM		 4575 off += vma_page_aligned_bias (hdr->sh_addr, off,
4576 bed->maxpagesize);
4577 else
4578 off += vma_page_aligned_bias (hdr->sh_addr, off,
4579 hdr->sh_addralign);
4580 off = _bfd_elf_assign_file_position_for_section (hdr, off,
4581 FALSE);
4582 }
4583 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4584 && hdr->bfd_section == NULL)
4585 || hdr == i_shdrpp[tdata->symtab_section]
4586 || hdr == i_shdrpp[tdata->symtab_shndx_section]
4587 || hdr == i_shdrpp[tdata->strtab_section])
4588 hdr->sh_offset = -1;
4589 else
4590 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
5c182d5f
AM		 4591 }
4592
252b5132
RH		 4593 /* Now that we have set the section file positions, we can set up
4594 the file positions for the non PT_LOAD segments. */
f3520d2f
AM		 4595 count = 0;
4596 filehdr_vaddr = 0;
4597 filehdr_paddr = 0;
4598 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4599 phdrs_paddr = 0;
4600 phdrs = elf_tdata (abfd)->phdr;
4601 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4602 m != NULL;
4603 m = m->next, p++)
4604 {
4605 ++count;
4606 if (p->p_type != PT_LOAD)
4607 continue;
4608
4609 if (m->includes_filehdr)
4610 {
4611 filehdr_vaddr = p->p_vaddr;
4612 filehdr_paddr = p->p_paddr;
4613 }
4614 if (m->includes_phdrs)
4615 {
4616 phdrs_vaddr = p->p_vaddr;
4617 phdrs_paddr = p->p_paddr;
4618 if (m->includes_filehdr)
4619 {
4620 phdrs_vaddr += bed->s->sizeof_ehdr;
4621 phdrs_paddr += bed->s->sizeof_ehdr;
4622 }
4623 }
4624 }
4625
252b5132
RH		 4626 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4627 m != NULL;
4628 m = m->next, p++)
4629 {
129af99f 4630 if (p->p_type == PT_GNU_RELRO)
252b5132 4631 {
b84a33b5
AM		 4632 const Elf_Internal_Phdr *lp;
4633
129af99f 4634 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
1ea63fd2 4635
129af99f 4636 if (link_info != NULL)
8c37241b 4637 {
129af99f
AS		 4638 /* During linking the range of the RELRO segment is passed
4639 in link_info. */
8c37241b
JJ		 4640 for (lp = phdrs; lp < phdrs + count; ++lp)
4641 {
4642 if (lp->p_type == PT_LOAD
8c37241b 4643 && lp->p_vaddr >= link_info->relro_start
b84a33b5
AM		 4644 && lp->p_vaddr < link_info->relro_end
4645 && lp->p_vaddr + lp->p_filesz >= link_info->relro_end)
8c37241b
JJ		 4646 break;
4647 }
8c37241b 4648 }
129af99f
AS		 4649 else
4650 {
4651 /* Otherwise we are copying an executable or shared
b84a33b5 4652 library, but we need to use the same linker logic. */
129af99f
AS		 4653 for (lp = phdrs; lp < phdrs + count; ++lp)
4654 {
4655 if (lp->p_type == PT_LOAD
4656 && lp->p_paddr == p->p_paddr)
4657 break;
4658 }
b84a33b5
AM		 4659 }
4660
4661 if (lp < phdrs + count)
4662 {
4663 p->p_vaddr = lp->p_vaddr;
4664 p->p_paddr = lp->p_paddr;
4665 p->p_offset = lp->p_offset;
4666 if (link_info != NULL)
4667 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4668 else if (m->p_size_valid)
4669 p->p_filesz = m->p_size;
129af99f
AS		 4670 else
4671 abort ();
b84a33b5
AM		 4672 p->p_memsz = p->p_filesz;
4673 p->p_align = 1;
4674 p->p_flags = (lp->p_flags & ~PF_W);
129af99f 4675 }
b84a33b5
AM		 4676 else if (link_info != NULL)
4677 {
4678 memset (p, 0, sizeof *p);
4679 p->p_type = PT_NULL;
4680 }
4681 else
4682 abort ();
129af99f
AS		 4683 }
4684 else if (m->count != 0)
4685 {
4686 if (p->p_type != PT_LOAD
4687 && (p->p_type != PT_NOTE
4688 || bfd_get_format (abfd) != bfd_core))
4689 {
4690 Elf_Internal_Shdr *hdr;
4691 asection *sect;
4692
4693 BFD_ASSERT (!m->includes_filehdr && !m->includes_phdrs);
4694
4695 sect = m->sections[m->count - 1];
4696 hdr = &elf_section_data (sect)->this_hdr;
4697 p->p_filesz = sect->filepos - m->sections[0]->filepos;
4698 if (hdr->sh_type != SHT_NOBITS)
4699 p->p_filesz += hdr->sh_size;
4700 p->p_offset = m->sections[0]->filepos;
4701 }
4702 }
4703 else if (m->includes_filehdr)
4704 {
4705 p->p_vaddr = filehdr_vaddr;
4706 if (! m->p_paddr_valid)
4707 p->p_paddr = filehdr_paddr;
4708 }
4709 else if (m->includes_phdrs)
4710 {
4711 p->p_vaddr = phdrs_vaddr;
4712 if (! m->p_paddr_valid)
4713 p->p_paddr = phdrs_paddr;
252b5132
RH		 4714 }
4715 }
4716
252b5132
RH		 4717 elf_tdata (abfd)->next_file_pos = off;
4718
b34976b6 4719 return TRUE;
252b5132
RH		 4720}
4721
252b5132
RH		 4722/* Work out the file positions of all the sections. This is called by
4723 _bfd_elf_compute_section_file_positions. All the section sizes and
4724 VMAs must be known before this is called.
4725
e0638f70
AM		 4726 Reloc sections come in two flavours: Those processed specially as
4727 "side-channel" data attached to a section to which they apply, and
4728 those that bfd doesn't process as relocations. The latter sort are
4729 stored in a normal bfd section by bfd_section_from_shdr. We don't
4730 consider the former sort here, unless they form part of the loadable
4731 image. Reloc sections not assigned here will be handled later by
4732 assign_file_positions_for_relocs.
252b5132
RH		 4733
4734 We also don't set the positions of the .symtab and .strtab here. */
4735
b34976b6 4736static bfd_boolean
c84fca4d
AO		 4737assign_file_positions_except_relocs (bfd *abfd,
4738 struct bfd_link_info *link_info)
252b5132 4739{
5c182d5f
AM		 4740 struct elf_obj_tdata *tdata = elf_tdata (abfd);
4741 Elf_Internal_Ehdr *i_ehdrp = elf_elfheader (abfd);
252b5132 4742 file_ptr off;
9c5bfbb7 4743 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4744
4745 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4746 && bfd_get_format (abfd) != bfd_core)
4747 {
5c182d5f
AM		 4748 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4749 unsigned int num_sec = elf_numsections (abfd);
252b5132
RH		 4750 Elf_Internal_Shdr **hdrpp;
4751 unsigned int i;
4752
4753 /* Start after the ELF header. */
4754 off = i_ehdrp->e_ehsize;
4755
4756 /* We are not creating an executable, which means that we are
4757 not creating a program header, and that the actual order of
4758 the sections in the file is unimportant. */
9ad5cbcf 4759 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH		 4760 {
4761 Elf_Internal_Shdr *hdr;
4762
4763 hdr = *hdrpp;
e0638f70
AM		 4764 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4765 && hdr->bfd_section == NULL)
9ad5cbcf
AM		 4766 || i == tdata->symtab_section
4767 || i == tdata->symtab_shndx_section
252b5132
RH		 4768 || i == tdata->strtab_section)
4769 {
4770 hdr->sh_offset = -1;
252b5132 4771 }
9ad5cbcf 4772 else
b34976b6 4773 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132
RH		 4774 }
4775 }
4776 else
4777 {
f3520d2f
AM		 4778 unsigned int alloc;
4779
252b5132 4780 /* Assign file positions for the loaded sections based on the
08a40648 4781 assignment of sections to segments. */
f3520d2f
AM		 4782 if (!assign_file_positions_for_load_sections (abfd, link_info))
4783 return FALSE;
4784
4785 /* And for non-load sections. */
4786 if (!assign_file_positions_for_non_load_sections (abfd, link_info))
4787 return FALSE;
4788
e36284ab
AM		 4789 if (bed->elf_backend_modify_program_headers != NULL)
4790 {
4791 if (!(*bed->elf_backend_modify_program_headers) (abfd, link_info))
4792 return FALSE;
4793 }
4794
f3520d2f
AM		 4795 /* Write out the program headers. */
4796 alloc = tdata->program_header_size / bed->s->sizeof_phdr;
4797 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
4798 || bed->s->write_out_phdrs (abfd, tdata->phdr, alloc) != 0)
b34976b6 4799 return FALSE;
252b5132 4800
5c182d5f 4801 off = tdata->next_file_pos;
252b5132
RH		 4802 }
4803
4804 /* Place the section headers. */
45d6a902 4805 off = align_file_position (off, 1 << bed->s->log_file_align);
252b5132
RH		 4806 i_ehdrp->e_shoff = off;
4807 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4808
5c182d5f 4809 tdata->next_file_pos = off;
252b5132 4810
b34976b6 4811 return TRUE;
252b5132
RH		 4812}
4813
b34976b6 4814static bfd_boolean
217aa764 4815prep_headers (bfd *abfd)
252b5132
RH		 4816{
4817 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4818 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
2b0f7ef9 4819 struct elf_strtab_hash *shstrtab;
9c5bfbb7 4820 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4821
4822 i_ehdrp = elf_elfheader (abfd);
252b5132 4823
2b0f7ef9 4824 shstrtab = _bfd_elf_strtab_init ();
252b5132 4825 if (shstrtab == NULL)
b34976b6 4826 return FALSE;
252b5132
RH		 4827
4828 elf_shstrtab (abfd) = shstrtab;
4829
4830 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4831 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4832 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4833 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4834
4835 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4836 i_ehdrp->e_ident[EI_DATA] =
4837 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4838 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4839
252b5132
RH		 4840 if ((abfd->flags & DYNAMIC) != 0)
4841 i_ehdrp->e_type = ET_DYN;
4842 else if ((abfd->flags & EXEC_P) != 0)
4843 i_ehdrp->e_type = ET_EXEC;
4844 else if (bfd_get_format (abfd) == bfd_core)
4845 i_ehdrp->e_type = ET_CORE;
4846 else
4847 i_ehdrp->e_type = ET_REL;
4848
4849 switch (bfd_get_arch (abfd))
4850 {
4851 case bfd_arch_unknown:
4852 i_ehdrp->e_machine = EM_NONE;
4853 break;
aa4f99bb
AO		 4854
4855 /* There used to be a long list of cases here, each one setting
4856 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4857 in the corresponding bfd definition. To avoid duplication,
4858 the switch was removed. Machines that need special handling
4859 can generally do it in elf_backend_final_write_processing(),
4860 unless they need the information earlier than the final write.
4861 Such need can generally be supplied by replacing the tests for
4862 e_machine with the conditions used to determine it. */
252b5132 4863 default:
9c5bfbb7
AM		 4864 i_ehdrp->e_machine = bed->elf_machine_code;
4865 }
aa4f99bb 4866
252b5132
RH		 4867 i_ehdrp->e_version = bed->s->ev_current;
4868 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4869
c044fabd 4870 /* No program header, for now. */
252b5132
RH		 4871 i_ehdrp->e_phoff = 0;
4872 i_ehdrp->e_phentsize = 0;
4873 i_ehdrp->e_phnum = 0;
4874
c044fabd 4875 /* Each bfd section is section header entry. */
252b5132
RH		 4876 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4877 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4878
c044fabd 4879 /* If we're building an executable, we'll need a program header table. */
252b5132 4880 if (abfd->flags & EXEC_P)
0e71e495
BE		 4881 /* It all happens later. */
4882 ;
252b5132
RH		 4883 else
4884 {
4885 i_ehdrp->e_phentsize = 0;
4886 i_phdrp = 0;
4887 i_ehdrp->e_phoff = 0;
4888 }
4889
4890 elf_tdata (abfd)->symtab_hdr.sh_name =
b34976b6 4891 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
252b5132 4892 elf_tdata (abfd)->strtab_hdr.sh_name =
b34976b6 4893 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
252b5132 4894 elf_tdata (abfd)->shstrtab_hdr.sh_name =
b34976b6 4895 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
252b5132
RH		 4896 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4897 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4898 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
b34976b6 4899 return FALSE;
252b5132 4900
b34976b6 4901 return TRUE;
252b5132
RH		 4902}
4903
4904/* Assign file positions for all the reloc sections which are not part
4905 of the loadable file image. */
4906
4907void
217aa764 4908_bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
252b5132
RH		 4909{
4910 file_ptr off;
9ad5cbcf 4911 unsigned int i, num_sec;
252b5132
RH		 4912 Elf_Internal_Shdr **shdrpp;
4913
4914 off = elf_tdata (abfd)->next_file_pos;
4915
9ad5cbcf
AM		 4916 num_sec = elf_numsections (abfd);
4917 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
252b5132
RH		 4918 {
4919 Elf_Internal_Shdr *shdrp;
4920
4921 shdrp = *shdrpp;
4922 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4923 && shdrp->sh_offset == -1)
b34976b6 4924 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
252b5132
RH		 4925 }
4926
4927 elf_tdata (abfd)->next_file_pos = off;
4928}
4929
b34976b6 4930bfd_boolean
217aa764 4931_bfd_elf_write_object_contents (bfd *abfd)
252b5132 4932{
9c5bfbb7 4933 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4934 Elf_Internal_Ehdr *i_ehdrp;
4935 Elf_Internal_Shdr **i_shdrp;
b34976b6 4936 bfd_boolean failed;
9ad5cbcf 4937 unsigned int count, num_sec;
252b5132
RH		 4938
4939 if (! abfd->output_has_begun
217aa764 4940 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 4941 return FALSE;
252b5132
RH		 4942
4943 i_shdrp = elf_elfsections (abfd);
4944 i_ehdrp = elf_elfheader (abfd);
4945
b34976b6 4946 failed = FALSE;
252b5132
RH		 4947 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4948 if (failed)
b34976b6 4949 return FALSE;
252b5132
RH		 4950
4951 _bfd_elf_assign_file_positions_for_relocs (abfd);
4952
c044fabd 4953 /* After writing the headers, we need to write the sections too... */
9ad5cbcf
AM		 4954 num_sec = elf_numsections (abfd);
4955 for (count = 1; count < num_sec; count++)
252b5132
RH		 4956 {
4957 if (bed->elf_backend_section_processing)
4958 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4959 if (i_shdrp[count]->contents)
4960 {
dc810e39
AM		 4961 bfd_size_type amt = i_shdrp[count]->sh_size;
4962
252b5132 4963 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
dc810e39 4964 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
b34976b6 4965 return FALSE;
252b5132
RH		 4966 }
4967 }
4968
4969 /* Write out the section header names. */
26ae6d5e
DJ		 4970 if (elf_shstrtab (abfd) != NULL
4971 && (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
08a40648 4972 || !_bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd))))
b34976b6 4973 return FALSE;
252b5132
RH		 4974
4975 if (bed->elf_backend_final_write_processing)
4976 (*bed->elf_backend_final_write_processing) (abfd,
4977 elf_tdata (abfd)->linker);
4978
ff59fc36
RM		 4979 if (!bed->s->write_shdrs_and_ehdr (abfd))
4980 return FALSE;
4981
4982 /* This is last since write_shdrs_and_ehdr can touch i_shdrp[0]. */
bfb53a4f
RM		 4983 if (elf_tdata (abfd)->after_write_object_contents)
4984 return (*elf_tdata (abfd)->after_write_object_contents) (abfd);
ff59fc36
RM		 4985
4986 return TRUE;
252b5132
RH		 4987}
4988
b34976b6 4989bfd_boolean
217aa764 4990_bfd_elf_write_corefile_contents (bfd *abfd)
252b5132 4991{
c044fabd 4992 /* Hopefully this can be done just like an object file. */
252b5132
RH		 4993 return _bfd_elf_write_object_contents (abfd);
4994}
c044fabd
KH		 4995
4996/* Given a section, search the header to find them. */
4997
cb33740c 4998unsigned int
198beae2 4999_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
252b5132 5000{
9c5bfbb7 5001 const struct elf_backend_data *bed;
cb33740c 5002 unsigned int index;
252b5132 5003
9ad5cbcf
AM		 5004 if (elf_section_data (asect) != NULL
5005 && elf_section_data (asect)->this_idx != 0)
5006 return elf_section_data (asect)->this_idx;
5007
5008 if (bfd_is_abs_section (asect))
af746e92
AM		 5009 index = SHN_ABS;
5010 else if (bfd_is_com_section (asect))
5011 index = SHN_COMMON;
5012 else if (bfd_is_und_section (asect))
5013 index = SHN_UNDEF;
5014 else
cb33740c 5015 index = SHN_BAD;
252b5132 5016
af746e92 5017 bed = get_elf_backend_data (abfd);
252b5132
RH		 5018 if (bed->elf_backend_section_from_bfd_section)
5019 {
af746e92 5020 int retval = index;
9ad5cbcf 5021
af746e92
AM		 5022 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
5023 return retval;
252b5132
RH		 5024 }
5025
cb33740c 5026 if (index == SHN_BAD)
af746e92 5027 bfd_set_error (bfd_error_nonrepresentable_section);
252b5132 5028
af746e92 5029 return index;
252b5132
RH		 5030}
5031
5032/* Given a BFD symbol, return the index in the ELF symbol table, or -1
5033 on error. */
5034
5035int
217aa764 5036_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
252b5132
RH		 5037{
5038 asymbol *asym_ptr = *asym_ptr_ptr;
5039 int idx;
5040 flagword flags = asym_ptr->flags;
5041
5042 /* When gas creates relocations against local labels, it creates its
5043 own symbol for the section, but does put the symbol into the
5044 symbol chain, so udata is 0. When the linker is generating
5045 relocatable output, this section symbol may be for one of the
5046 input sections rather than the output section. */
5047 if (asym_ptr->udata.i == 0
5048 && (flags & BSF_SECTION_SYM)
5049 && asym_ptr->section)
5050 {
5372391b 5051 asection *sec;
252b5132
RH		 5052 int indx;
5053
5372391b
AM		 5054 sec = asym_ptr->section;
5055 if (sec->owner != abfd && sec->output_section != NULL)
5056 sec = sec->output_section;
5057 if (sec->owner == abfd
5058 && (indx = sec->index) < elf_num_section_syms (abfd)
4e89ac30 5059 && elf_section_syms (abfd)[indx] != NULL)
252b5132
RH		 5060 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
5061 }
5062
5063 idx = asym_ptr->udata.i;
5064
5065 if (idx == 0)
5066 {
5067 /* This case can occur when using --strip-symbol on a symbol
08a40648 5068 which is used in a relocation entry. */
252b5132 5069 (*_bfd_error_handler)
d003868e
AM		 5070 (_("%B: symbol `%s' required but not present"),
5071 abfd, bfd_asymbol_name (asym_ptr));
252b5132
RH		 5072 bfd_set_error (bfd_error_no_symbols);
5073 return -1;
5074 }
5075
5076#if DEBUG & 4
5077 {
5078 fprintf (stderr,
661a3fd4 5079 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
252b5132
RH		 5080 (long) asym_ptr, asym_ptr->name, idx, flags,
5081 elf_symbol_flags (flags));
5082 fflush (stderr);
5083 }
5084#endif
5085
5086 return idx;
5087}
5088
84d1d650 5089/* Rewrite program header information. */
252b5132 5090
b34976b6 5091static bfd_boolean
84d1d650 5092rewrite_elf_program_header (bfd *ibfd, bfd *obfd)
252b5132 5093{
b34976b6
AM		 5094 Elf_Internal_Ehdr *iehdr;
5095 struct elf_segment_map *map;
5096 struct elf_segment_map *map_first;
5097 struct elf_segment_map **pointer_to_map;
5098 Elf_Internal_Phdr *segment;
5099 asection *section;
5100 unsigned int i;
5101 unsigned int num_segments;
5102 bfd_boolean phdr_included = FALSE;
5c44b38e 5103 bfd_boolean p_paddr_valid;
b34976b6
AM		 5104 bfd_vma maxpagesize;
5105 struct elf_segment_map *phdr_adjust_seg = NULL;
5106 unsigned int phdr_adjust_num = 0;
9c5bfbb7 5107 const struct elf_backend_data *bed;
bc67d8a6 5108
caf47ea6 5109 bed = get_elf_backend_data (ibfd);
252b5132
RH		 5110 iehdr = elf_elfheader (ibfd);
5111
bc67d8a6 5112 map_first = NULL;
c044fabd 5113 pointer_to_map = &map_first;
252b5132
RH		 5114
5115 num_segments = elf_elfheader (ibfd)->e_phnum;
bc67d8a6
NC		 5116 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
5117
5118 /* Returns the end address of the segment + 1. */
aecc8f8a
AM		 5119#define SEGMENT_END(segment, start) \
5120 (start + (segment->p_memsz > segment->p_filesz \
5121 ? segment->p_memsz : segment->p_filesz))
bc67d8a6 5122
eecdbe52
JJ		 5123#define SECTION_SIZE(section, segment) \
5124 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
5125 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
eea6121a 5126 ? section->size : 0)
eecdbe52 5127
b34976b6 5128 /* Returns TRUE if the given section is contained within
bc67d8a6 5129 the given segment. VMA addresses are compared. */
aecc8f8a
AM		 5130#define IS_CONTAINED_BY_VMA(section, segment) \
5131 (section->vma >= segment->p_vaddr \
eecdbe52 5132 && (section->vma + SECTION_SIZE (section, segment) \
aecc8f8a 5133 <= (SEGMENT_END (segment, segment->p_vaddr))))
c044fabd 5134
b34976b6 5135 /* Returns TRUE if the given section is contained within
bc67d8a6 5136 the given segment. LMA addresses are compared. */
aecc8f8a
AM		 5137#define IS_CONTAINED_BY_LMA(section, segment, base) \
5138 (section->lma >= base \
eecdbe52 5139 && (section->lma + SECTION_SIZE (section, segment) \
aecc8f8a 5140 <= SEGMENT_END (segment, base)))
252b5132 5141
0efc80c8
L		 5142 /* Handle PT_NOTE segment. */
5143#define IS_NOTE(p, s) \
aecc8f8a 5144 (p->p_type == PT_NOTE \
0efc80c8 5145 && elf_section_type (s) == SHT_NOTE \
aecc8f8a 5146 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 5147 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 5148 <= p->p_offset + p->p_filesz))
252b5132 5149
0efc80c8
L		 5150 /* Special case: corefile "NOTE" section containing regs, prpsinfo
5151 etc. */
5152#define IS_COREFILE_NOTE(p, s) \
5153 (IS_NOTE (p, s) \
5154 && bfd_get_format (ibfd) == bfd_core \
5155 && s->vma == 0 \
5156 && s->lma == 0)
5157
252b5132
RH		 5158 /* The complicated case when p_vaddr is 0 is to handle the Solaris
5159 linker, which generates a PT_INTERP section with p_vaddr and
5160 p_memsz set to 0. */
aecc8f8a
AM		 5161#define IS_SOLARIS_PT_INTERP(p, s) \
5162 (p->p_vaddr == 0 \
5163 && p->p_paddr == 0 \
5164 && p->p_memsz == 0 \
5165 && p->p_filesz > 0 \
5166 && (s->flags & SEC_HAS_CONTENTS) != 0 \
eea6121a 5167 && s->size > 0 \
aecc8f8a 5168 && (bfd_vma) s->filepos >= p->p_offset \
cb3ff1e5 5169 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 5170 <= p->p_offset + p->p_filesz))
5c440b1e 5171
bc67d8a6
NC		 5172 /* Decide if the given section should be included in the given segment.
5173 A section will be included if:
f5ffc919 5174 1. It is within the address space of the segment -- we use the LMA
08a40648 5175 if that is set for the segment and the VMA otherwise,
0efc80c8
L		 5176 2. It is an allocated section or a NOTE section in a PT_NOTE
5177 segment.
bc67d8a6 5178 3. There is an output section associated with it,
eecdbe52 5179 4. The section has not already been allocated to a previous segment.
2b05f1b7 5180 5. PT_GNU_STACK segments do not include any sections.
03394ac9 5181 6. PT_TLS segment includes only SHF_TLS sections.
6f79b219
JJ		 5182 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments.
5183 8. PT_DYNAMIC should not contain empty sections at the beginning
08a40648 5184 (with the possible exception of .dynamic). */
9f17e2a6 5185#define IS_SECTION_IN_INPUT_SEGMENT(section, segment, bed) \
2b05f1b7
L		 5186 ((((segment->p_paddr \
5187 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
5188 : IS_CONTAINED_BY_VMA (section, segment)) \
5189 && (section->flags & SEC_ALLOC) != 0) \
0efc80c8 5190 || IS_NOTE (segment, section)) \
2b05f1b7
L		 5191 && segment->p_type != PT_GNU_STACK \
5192 && (segment->p_type != PT_TLS \
5193 || (section->flags & SEC_THREAD_LOCAL)) \
5194 && (segment->p_type == PT_LOAD \
5195 || segment->p_type == PT_TLS \
5196 || (section->flags & SEC_THREAD_LOCAL) == 0) \
5197 && (segment->p_type != PT_DYNAMIC \
5198 || SECTION_SIZE (section, segment) > 0 \
5199 || (segment->p_paddr \
5200 ? segment->p_paddr != section->lma \
5201 : segment->p_vaddr != section->vma) \
5202 || (strcmp (bfd_get_section_name (ibfd, section), ".dynamic") \
5203 == 0)) \
0067a569 5204 && !section->segment_mark)
bc67d8a6 5205
9f17e2a6
L		 5206/* If the output section of a section in the input segment is NULL,
5207 it is removed from the corresponding output segment. */
5208#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
5209 (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed) \
5210 && section->output_section != NULL)
5211
b34976b6 5212 /* Returns TRUE iff seg1 starts after the end of seg2. */
b5f852ea
NC		 5213#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
5214 (seg1->field >= SEGMENT_END (seg2, seg2->field))
5215
5216 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
5217 their VMA address ranges and their LMA address ranges overlap.
5218 It is possible to have overlapping VMA ranges without overlapping LMA
5219 ranges. RedBoot images for example can have both .data and .bss mapped
5220 to the same VMA range, but with the .data section mapped to a different
5221 LMA. */
aecc8f8a 5222#define SEGMENT_OVERLAPS(seg1, seg2) \
b5f852ea 5223 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
08a40648 5224 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
b5f852ea 5225 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
08a40648 5226 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
bc67d8a6
NC		 5227
5228 /* Initialise the segment mark field. */
5229 for (section = ibfd->sections; section != NULL; section = section->next)
b34976b6 5230 section->segment_mark = FALSE;
bc67d8a6 5231
5c44b38e
AM		 5232 /* The Solaris linker creates program headers in which all the
5233 p_paddr fields are zero. When we try to objcopy or strip such a
5234 file, we get confused. Check for this case, and if we find it
5235 don't set the p_paddr_valid fields. */
5236 p_paddr_valid = FALSE;
5237 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5238 i < num_segments;
5239 i++, segment++)
5240 if (segment->p_paddr != 0)
5241 {
5242 p_paddr_valid = TRUE;
5243 break;
5244 }
5245
252b5132 5246 /* Scan through the segments specified in the program header
bc67d8a6 5247 of the input BFD. For this first scan we look for overlaps
9ad5cbcf 5248 in the loadable segments. These can be created by weird
aecc8f8a 5249 parameters to objcopy. Also, fix some solaris weirdness. */
bc67d8a6
NC		 5250 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5251 i < num_segments;
c044fabd 5252 i++, segment++)
252b5132 5253 {
252b5132 5254 unsigned int j;
c044fabd 5255 Elf_Internal_Phdr *segment2;
252b5132 5256
aecc8f8a
AM		 5257 if (segment->p_type == PT_INTERP)
5258 for (section = ibfd->sections; section; section = section->next)
5259 if (IS_SOLARIS_PT_INTERP (segment, section))
5260 {
5261 /* Mininal change so that the normal section to segment
4cc11e76 5262 assignment code will work. */
aecc8f8a
AM		 5263 segment->p_vaddr = section->vma;
5264 break;
5265 }
5266
bc67d8a6 5267 if (segment->p_type != PT_LOAD)
b10a8ae0
L		 5268 {
5269 /* Remove PT_GNU_RELRO segment. */
5270 if (segment->p_type == PT_GNU_RELRO)
5271 segment->p_type = PT_NULL;
5272 continue;
5273 }
c044fabd 5274
bc67d8a6 5275 /* Determine if this segment overlaps any previous segments. */
0067a569 5276 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2++)
bc67d8a6
NC		 5277 {
5278 bfd_signed_vma extra_length;
c044fabd 5279
bc67d8a6 5280 if (segment2->p_type != PT_LOAD
0067a569 5281 || !SEGMENT_OVERLAPS (segment, segment2))
bc67d8a6 5282 continue;
c044fabd 5283
bc67d8a6
NC		 5284 /* Merge the two segments together. */
5285 if (segment2->p_vaddr < segment->p_vaddr)
5286 {
c044fabd 5287 /* Extend SEGMENT2 to include SEGMENT and then delete
08a40648 5288 SEGMENT. */
0067a569
AM		 5289 extra_length = (SEGMENT_END (segment, segment->p_vaddr)
5290 - SEGMENT_END (segment2, segment2->p_vaddr));
c044fabd 5291
bc67d8a6
NC		 5292 if (extra_length > 0)
5293 {
0067a569 5294 segment2->p_memsz += extra_length;
bc67d8a6
NC		 5295 segment2->p_filesz += extra_length;
5296 }
c044fabd 5297
bc67d8a6 5298 segment->p_type = PT_NULL;
c044fabd 5299
bc67d8a6
NC		 5300 /* Since we have deleted P we must restart the outer loop. */
5301 i = 0;
5302 segment = elf_tdata (ibfd)->phdr;
5303 break;
5304 }
5305 else
5306 {
c044fabd 5307 /* Extend SEGMENT to include SEGMENT2 and then delete
08a40648 5308 SEGMENT2. */
0067a569
AM		 5309 extra_length = (SEGMENT_END (segment2, segment2->p_vaddr)
5310 - SEGMENT_END (segment, segment->p_vaddr));
c044fabd 5311
bc67d8a6
NC		 5312 if (extra_length > 0)
5313 {
0067a569 5314 segment->p_memsz += extra_length;
bc67d8a6
NC		 5315 segment->p_filesz += extra_length;
5316 }
c044fabd 5317
bc67d8a6
NC		 5318 segment2->p_type = PT_NULL;
5319 }
5320 }
5321 }
c044fabd 5322
bc67d8a6
NC		 5323 /* The second scan attempts to assign sections to segments. */
5324 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5325 i < num_segments;
0067a569 5326 i++, segment++)
bc67d8a6 5327 {
0067a569
AM		 5328 unsigned int section_count;
5329 asection **sections;
5330 asection *output_section;
5331 unsigned int isec;
5332 bfd_vma matching_lma;
5333 bfd_vma suggested_lma;
5334 unsigned int j;
dc810e39 5335 bfd_size_type amt;
0067a569
AM		 5336 asection *first_section;
5337 bfd_boolean first_matching_lma;
5338 bfd_boolean first_suggested_lma;
bc67d8a6
NC		 5339
5340 if (segment->p_type == PT_NULL)
5341 continue;
c044fabd 5342
9f17e2a6 5343 first_section = NULL;
bc67d8a6 5344 /* Compute how many sections might be placed into this segment. */
b5f852ea
NC		 5345 for (section = ibfd->sections, section_count = 0;
5346 section != NULL;
5347 section = section->next)
9f17e2a6
L		 5348 {
5349 /* Find the first section in the input segment, which may be
5350 removed from the corresponding output segment. */
5351 if (IS_SECTION_IN_INPUT_SEGMENT (section, segment, bed))
5352 {
5353 if (first_section == NULL)
5354 first_section = section;
5355 if (section->output_section != NULL)
5356 ++section_count;
5357 }
5358 }
811072d8 5359
b5f852ea
NC		 5360 /* Allocate a segment map big enough to contain
5361 all of the sections we have selected. */
dc810e39
AM		 5362 amt = sizeof (struct elf_segment_map);
5363 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
41f8ce69 5364 map = bfd_zalloc (obfd, amt);
bc67d8a6 5365 if (map == NULL)
b34976b6 5366 return FALSE;
252b5132
RH		 5367
5368 /* Initialise the fields of the segment map. Default to
5369 using the physical address of the segment in the input BFD. */
0067a569
AM		 5370 map->next = NULL;
5371 map->p_type = segment->p_type;
5372 map->p_flags = segment->p_flags;
bc67d8a6 5373 map->p_flags_valid = 1;
55d55ac7 5374
9f17e2a6
L		 5375 /* If the first section in the input segment is removed, there is
5376 no need to preserve segment physical address in the corresponding
5377 output segment. */
945c025a 5378 if (!first_section || first_section->output_section != NULL)
9f17e2a6
L		 5379 {
5380 map->p_paddr = segment->p_paddr;
5c44b38e 5381 map->p_paddr_valid = p_paddr_valid;
9f17e2a6 5382 }
252b5132
RH		 5383
5384 /* Determine if this segment contains the ELF file header
5385 and if it contains the program headers themselves. */
bc67d8a6
NC		 5386 map->includes_filehdr = (segment->p_offset == 0
5387 && segment->p_filesz >= iehdr->e_ehsize);
bc67d8a6 5388 map->includes_phdrs = 0;
252b5132 5389
0067a569 5390 if (!phdr_included || segment->p_type != PT_LOAD)
252b5132 5391 {
bc67d8a6
NC		 5392 map->includes_phdrs =
5393 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5394 && (segment->p_offset + segment->p_filesz
252b5132
RH		 5395 >= ((bfd_vma) iehdr->e_phoff
5396 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 5397
bc67d8a6 5398 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 5399 phdr_included = TRUE;
252b5132
RH		 5400 }
5401
bc67d8a6 5402 if (section_count == 0)
252b5132
RH		 5403 {
5404 /* Special segments, such as the PT_PHDR segment, may contain
5405 no sections, but ordinary, loadable segments should contain
1ed89aa9
NC		 5406 something. They are allowed by the ELF spec however, so only
5407 a warning is produced. */
bc67d8a6 5408 if (segment->p_type == PT_LOAD)
0067a569
AM		 5409 (*_bfd_error_handler) (_("%B: warning: Empty loadable segment"
5410 " detected, is this intentional ?\n"),
5411 ibfd);
252b5132 5412
bc67d8a6 5413 map->count = 0;
c044fabd
KH		 5414 *pointer_to_map = map;
5415 pointer_to_map = &map->next;
252b5132
RH		 5416
5417 continue;
5418 }
5419
5420 /* Now scan the sections in the input BFD again and attempt
5421 to add their corresponding output sections to the segment map.
5422 The problem here is how to handle an output section which has
5423 been moved (ie had its LMA changed). There are four possibilities:
5424
5425 1. None of the sections have been moved.
5426 In this case we can continue to use the segment LMA from the
5427 input BFD.
5428
5429 2. All of the sections have been moved by the same amount.
5430 In this case we can change the segment's LMA to match the LMA
5431 of the first section.
5432
5433 3. Some of the sections have been moved, others have not.
5434 In this case those sections which have not been moved can be
5435 placed in the current segment which will have to have its size,
5436 and possibly its LMA changed, and a new segment or segments will
5437 have to be created to contain the other sections.
5438
b5f852ea 5439 4. The sections have been moved, but not by the same amount.
252b5132
RH		 5440 In this case we can change the segment's LMA to match the LMA
5441 of the first section and we will have to create a new segment
5442 or segments to contain the other sections.
5443
5444 In order to save time, we allocate an array to hold the section
5445 pointers that we are interested in. As these sections get assigned
5446 to a segment, they are removed from this array. */
5447
d0fb9a8d 5448 sections = bfd_malloc2 (section_count, sizeof (asection *));
252b5132 5449 if (sections == NULL)
b34976b6 5450 return FALSE;
252b5132
RH		 5451
5452 /* Step One: Scan for segment vs section LMA conflicts.
5453 Also add the sections to the section array allocated above.
5454 Also add the sections to the current segment. In the common
5455 case, where the sections have not been moved, this means that
5456 we have completely filled the segment, and there is nothing
5457 more to do. */
252b5132 5458 isec = 0;
72730e0c 5459 matching_lma = 0;
252b5132 5460 suggested_lma = 0;
0067a569
AM		 5461 first_matching_lma = TRUE;
5462 first_suggested_lma = TRUE;
252b5132 5463
147d51c2 5464 for (section = ibfd->sections;
bc67d8a6
NC		 5465 section != NULL;
5466 section = section->next)
147d51c2
L		 5467 if (section == first_section)
5468 break;
5469
5470 for (j = 0; section != NULL; section = section->next)
252b5132 5471 {
caf47ea6 5472 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 5473 {
bc67d8a6
NC		 5474 output_section = section->output_section;
5475
0067a569 5476 sections[j++] = section;
252b5132
RH		 5477
5478 /* The Solaris native linker always sets p_paddr to 0.
5479 We try to catch that case here, and set it to the
5e8d7549
NC		 5480 correct value. Note - some backends require that
5481 p_paddr be left as zero. */
5c44b38e 5482 if (!p_paddr_valid
4455705d 5483 && segment->p_vaddr != 0
0067a569 5484 && !bed->want_p_paddr_set_to_zero
252b5132 5485 && isec == 0
bc67d8a6 5486 && output_section->lma != 0
0067a569
AM		 5487 && output_section->vma == (segment->p_vaddr
5488 + (map->includes_filehdr
5489 ? iehdr->e_ehsize
5490 : 0)
5491 + (map->includes_phdrs
5492 ? (iehdr->e_phnum
5493 * iehdr->e_phentsize)
5494 : 0)))
bc67d8a6 5495 map->p_paddr = segment->p_vaddr;
252b5132
RH		 5496
5497 /* Match up the physical address of the segment with the
5498 LMA address of the output section. */
bc67d8a6 5499 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549 5500 || IS_COREFILE_NOTE (segment, section)
0067a569
AM		 5501 || (bed->want_p_paddr_set_to_zero
5502 && IS_CONTAINED_BY_VMA (output_section, segment)))
252b5132 5503 {
0067a569
AM		 5504 if (first_matching_lma || output_section->lma < matching_lma)
5505 {
5506 matching_lma = output_section->lma;
5507 first_matching_lma = FALSE;
5508 }
252b5132
RH		 5509
5510 /* We assume that if the section fits within the segment
bc67d8a6 5511 then it does not overlap any other section within that
252b5132 5512 segment. */
0067a569
AM		 5513 map->sections[isec++] = output_section;
5514 }
5515 else if (first_suggested_lma)
5516 {
5517 suggested_lma = output_section->lma;
5518 first_suggested_lma = FALSE;
252b5132 5519 }
147d51c2
L		 5520
5521 if (j == section_count)
5522 break;
252b5132
RH		 5523 }
5524 }
5525
bc67d8a6 5526 BFD_ASSERT (j == section_count);
252b5132
RH		 5527
5528 /* Step Two: Adjust the physical address of the current segment,
5529 if necessary. */
bc67d8a6 5530 if (isec == section_count)
252b5132
RH		 5531 {
5532 /* All of the sections fitted within the segment as currently
5533 specified. This is the default case. Add the segment to
5534 the list of built segments and carry on to process the next
5535 program header in the input BFD. */
bc67d8a6 5536 map->count = section_count;
c044fabd
KH		 5537 *pointer_to_map = map;
5538 pointer_to_map = &map->next;
08a40648 5539
5c44b38e
AM		 5540 if (p_paddr_valid
5541 && !bed->want_p_paddr_set_to_zero
147d51c2 5542 && matching_lma != map->p_paddr
5c44b38e
AM		 5543 && !map->includes_filehdr
5544 && !map->includes_phdrs)
3271a814
NS		 5545 /* There is some padding before the first section in the
5546 segment. So, we must account for that in the output
5547 segment's vma. */
5548 map->p_vaddr_offset = matching_lma - map->p_paddr;
08a40648 5549
252b5132
RH		 5550 free (sections);
5551 continue;
5552 }
252b5132
RH		 5553 else
5554 {
0067a569 5555 if (!first_matching_lma)
72730e0c
AM		 5556 {
5557 /* At least one section fits inside the current segment.
5558 Keep it, but modify its physical address to match the
5559 LMA of the first section that fitted. */
bc67d8a6 5560 map->p_paddr = matching_lma;
72730e0c
AM		 5561 }
5562 else
5563 {
5564 /* None of the sections fitted inside the current segment.
5565 Change the current segment's physical address to match
5566 the LMA of the first section. */
bc67d8a6 5567 map->p_paddr = suggested_lma;
72730e0c
AM		 5568 }
5569
bc67d8a6
NC		 5570 /* Offset the segment physical address from the lma
5571 to allow for space taken up by elf headers. */
5572 if (map->includes_filehdr)
010c8431
AM		 5573 {
5574 if (map->p_paddr >= iehdr->e_ehsize)
5575 map->p_paddr -= iehdr->e_ehsize;
5576 else
5577 {
5578 map->includes_filehdr = FALSE;
5579 map->includes_phdrs = FALSE;
5580 }
5581 }
252b5132 5582
bc67d8a6
NC		 5583 if (map->includes_phdrs)
5584 {
010c8431
AM		 5585 if (map->p_paddr >= iehdr->e_phnum * iehdr->e_phentsize)
5586 {
5587 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5588
5589 /* iehdr->e_phnum is just an estimate of the number
5590 of program headers that we will need. Make a note
5591 here of the number we used and the segment we chose
5592 to hold these headers, so that we can adjust the
5593 offset when we know the correct value. */
5594 phdr_adjust_num = iehdr->e_phnum;
5595 phdr_adjust_seg = map;
5596 }
5597 else
5598 map->includes_phdrs = FALSE;
bc67d8a6 5599 }
252b5132
RH		 5600 }
5601
5602 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 5603 those that fit to the current segment and removing them from the
252b5132
RH		 5604 sections array; but making sure not to leave large gaps. Once all
5605 possible sections have been assigned to the current segment it is
5606 added to the list of built segments and if sections still remain
5607 to be assigned, a new segment is constructed before repeating
5608 the loop. */
5609 isec = 0;
5610 do
5611 {
bc67d8a6 5612 map->count = 0;
252b5132 5613 suggested_lma = 0;
0067a569 5614 first_suggested_lma = TRUE;
252b5132
RH		 5615
5616 /* Fill the current segment with sections that fit. */
bc67d8a6 5617 for (j = 0; j < section_count; j++)
252b5132 5618 {
bc67d8a6 5619 section = sections[j];
252b5132 5620
bc67d8a6 5621 if (section == NULL)
252b5132
RH		 5622 continue;
5623
bc67d8a6 5624 output_section = section->output_section;
252b5132 5625
bc67d8a6 5626 BFD_ASSERT (output_section != NULL);
c044fabd 5627
bc67d8a6
NC		 5628 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5629 || IS_COREFILE_NOTE (segment, section))
252b5132 5630 {
bc67d8a6 5631 if (map->count == 0)
252b5132
RH		 5632 {
5633 /* If the first section in a segment does not start at
bc67d8a6
NC		 5634 the beginning of the segment, then something is
5635 wrong. */
0067a569
AM		 5636 if (output_section->lma
5637 != (map->p_paddr
5638 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5639 + (map->includes_phdrs
5640 ? iehdr->e_phnum * iehdr->e_phentsize
5641 : 0)))
252b5132
RH		 5642 abort ();
5643 }
5644 else
5645 {
0067a569 5646 asection *prev_sec;
252b5132 5647
bc67d8a6 5648 prev_sec = map->sections[map->count - 1];
252b5132
RH		 5649
5650 /* If the gap between the end of the previous section
bc67d8a6
NC		 5651 and the start of this section is more than
5652 maxpagesize then we need to start a new segment. */
eea6121a 5653 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 5654 maxpagesize)
caf47ea6 5655 < BFD_ALIGN (output_section->lma, maxpagesize))
0067a569 5656 || (prev_sec->lma + prev_sec->size
079e9a2f 5657 > output_section->lma))
252b5132 5658 {
0067a569
AM		 5659 if (first_suggested_lma)
5660 {
5661 suggested_lma = output_section->lma;
5662 first_suggested_lma = FALSE;
5663 }
252b5132
RH		 5664
5665 continue;
5666 }
5667 }
5668
bc67d8a6 5669 map->sections[map->count++] = output_section;
252b5132
RH		 5670 ++isec;
5671 sections[j] = NULL;
b34976b6 5672 section->segment_mark = TRUE;
252b5132 5673 }
0067a569
AM		 5674 else if (first_suggested_lma)
5675 {
5676 suggested_lma = output_section->lma;
5677 first_suggested_lma = FALSE;
5678 }
252b5132
RH		 5679 }
5680
bc67d8a6 5681 BFD_ASSERT (map->count > 0);
252b5132
RH		 5682
5683 /* Add the current segment to the list of built segments. */
c044fabd
KH		 5684 *pointer_to_map = map;
5685 pointer_to_map = &map->next;
252b5132 5686
bc67d8a6 5687 if (isec < section_count)
252b5132
RH		 5688 {
5689 /* We still have not allocated all of the sections to
5690 segments. Create a new segment here, initialise it
5691 and carry on looping. */
dc810e39
AM		 5692 amt = sizeof (struct elf_segment_map);
5693 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
217aa764 5694 map = bfd_alloc (obfd, amt);
bc67d8a6 5695 if (map == NULL)
5ed6aba4
NC		 5696 {
5697 free (sections);
5698 return FALSE;
5699 }
252b5132
RH		 5700
5701 /* Initialise the fields of the segment map. Set the physical
5702 physical address to the LMA of the first section that has
5703 not yet been assigned. */
0067a569
AM		 5704 map->next = NULL;
5705 map->p_type = segment->p_type;
5706 map->p_flags = segment->p_flags;
5707 map->p_flags_valid = 1;
5708 map->p_paddr = suggested_lma;
5c44b38e 5709 map->p_paddr_valid = p_paddr_valid;
bc67d8a6 5710 map->includes_filehdr = 0;
0067a569 5711 map->includes_phdrs = 0;
252b5132
RH		 5712 }
5713 }
bc67d8a6 5714 while (isec < section_count);
252b5132
RH		 5715
5716 free (sections);
5717 }
5718
bc67d8a6
NC		 5719 elf_tdata (obfd)->segment_map = map_first;
5720
5721 /* If we had to estimate the number of program headers that were
9ad5cbcf 5722 going to be needed, then check our estimate now and adjust
bc67d8a6
NC		 5723 the offset if necessary. */
5724 if (phdr_adjust_seg != NULL)
5725 {
5726 unsigned int count;
c044fabd 5727
bc67d8a6 5728 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 5729 count++;
252b5132 5730
bc67d8a6
NC		 5731 if (count > phdr_adjust_num)
5732 phdr_adjust_seg->p_paddr
5733 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5734 }
c044fabd 5735
bc67d8a6 5736#undef SEGMENT_END
eecdbe52 5737#undef SECTION_SIZE
bc67d8a6
NC		 5738#undef IS_CONTAINED_BY_VMA
5739#undef IS_CONTAINED_BY_LMA
0efc80c8 5740#undef IS_NOTE
252b5132 5741#undef IS_COREFILE_NOTE
bc67d8a6 5742#undef IS_SOLARIS_PT_INTERP
9f17e2a6 5743#undef IS_SECTION_IN_INPUT_SEGMENT
bc67d8a6
NC		 5744#undef INCLUDE_SECTION_IN_SEGMENT
5745#undef SEGMENT_AFTER_SEGMENT
5746#undef SEGMENT_OVERLAPS
b34976b6 5747 return TRUE;
252b5132
RH		 5748}
5749
84d1d650
L		 5750/* Copy ELF program header information. */
5751
5752static bfd_boolean
5753copy_elf_program_header (bfd *ibfd, bfd *obfd)
5754{
5755 Elf_Internal_Ehdr *iehdr;
5756 struct elf_segment_map *map;
5757 struct elf_segment_map *map_first;
5758 struct elf_segment_map **pointer_to_map;
5759 Elf_Internal_Phdr *segment;
5760 unsigned int i;
5761 unsigned int num_segments;
5762 bfd_boolean phdr_included = FALSE;
88967714 5763 bfd_boolean p_paddr_valid;
84d1d650
L		 5764
5765 iehdr = elf_elfheader (ibfd);
5766
5767 map_first = NULL;
5768 pointer_to_map = &map_first;
5769
88967714
AM		 5770 /* If all the segment p_paddr fields are zero, don't set
5771 map->p_paddr_valid. */
5772 p_paddr_valid = FALSE;
84d1d650 5773 num_segments = elf_elfheader (ibfd)->e_phnum;
88967714
AM		 5774 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5775 i < num_segments;
5776 i++, segment++)
5777 if (segment->p_paddr != 0)
5778 {
5779 p_paddr_valid = TRUE;
5780 break;
5781 }
5782
84d1d650
L		 5783 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5784 i < num_segments;
5785 i++, segment++)
5786 {
5787 asection *section;
5788 unsigned int section_count;
5789 bfd_size_type amt;
5790 Elf_Internal_Shdr *this_hdr;
53020534 5791 asection *first_section = NULL;
c981028a 5792 asection *lowest_section = NULL;
84d1d650 5793
84d1d650
L		 5794 /* Compute how many sections are in this segment. */
5795 for (section = ibfd->sections, section_count = 0;
5796 section != NULL;
5797 section = section->next)
5798 {
5799 this_hdr = &(elf_section_data(section)->this_hdr);
5800 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
3271a814 5801 {
53020534 5802 if (!first_section)
c981028a
DJ		 5803 first_section = lowest_section = section;
5804 if (section->lma < lowest_section->lma)
5805 lowest_section = section;
3271a814
NS		 5806 section_count++;
5807 }
84d1d650
L		 5808 }
5809
5810 /* Allocate a segment map big enough to contain
5811 all of the sections we have selected. */
5812 amt = sizeof (struct elf_segment_map);
5813 if (section_count != 0)
5814 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
41f8ce69 5815 map = bfd_zalloc (obfd, amt);
84d1d650
L		 5816 if (map == NULL)
5817 return FALSE;
5818
5819 /* Initialize the fields of the output segment map with the
5820 input segment. */
5821 map->next = NULL;
5822 map->p_type = segment->p_type;
5823 map->p_flags = segment->p_flags;
5824 map->p_flags_valid = 1;
5825 map->p_paddr = segment->p_paddr;
88967714 5826 map->p_paddr_valid = p_paddr_valid;
3f570048
AM		 5827 map->p_align = segment->p_align;
5828 map->p_align_valid = 1;
3271a814 5829 map->p_vaddr_offset = 0;
84d1d650 5830
b10a8ae0
L		 5831 if (map->p_type == PT_GNU_RELRO
5832 && segment->p_filesz == segment->p_memsz)
5833 {
5834 /* The PT_GNU_RELRO segment may contain the first a few
5835 bytes in the .got.plt section even if the whole .got.plt
5836 section isn't in the PT_GNU_RELRO segment. We won't
5837 change the size of the PT_GNU_RELRO segment. */
5838 map->p_size = segment->p_filesz;
5839 map->p_size_valid = 1;
5840 }
5841
84d1d650
L		 5842 /* Determine if this segment contains the ELF file header
5843 and if it contains the program headers themselves. */
5844 map->includes_filehdr = (segment->p_offset == 0
5845 && segment->p_filesz >= iehdr->e_ehsize);
5846
5847 map->includes_phdrs = 0;
5848 if (! phdr_included || segment->p_type != PT_LOAD)
5849 {
5850 map->includes_phdrs =
5851 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5852 && (segment->p_offset + segment->p_filesz
5853 >= ((bfd_vma) iehdr->e_phoff
5854 + iehdr->e_phnum * iehdr->e_phentsize)));
5855
5856 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5857 phdr_included = TRUE;
5858 }
5859
2b0bc088
NC		 5860 if (map->includes_filehdr && first_section)
5861 /* We need to keep the space used by the headers fixed. */
5862 map->header_size = first_section->vma - segment->p_vaddr;
5863
88967714
AM		 5864 if (!map->includes_phdrs
5865 && !map->includes_filehdr
5866 && map->p_paddr_valid)
3271a814 5867 /* There is some other padding before the first section. */
c981028a 5868 map->p_vaddr_offset = ((lowest_section ? lowest_section->lma : 0)
53020534 5869 - segment->p_paddr);
08a40648 5870
84d1d650
L		 5871 if (section_count != 0)
5872 {
5873 unsigned int isec = 0;
5874
53020534 5875 for (section = first_section;
84d1d650
L		 5876 section != NULL;
5877 section = section->next)
5878 {
5879 this_hdr = &(elf_section_data(section)->this_hdr);
5880 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
53020534
L		 5881 {
5882 map->sections[isec++] = section->output_section;
5883 if (isec == section_count)
5884 break;
5885 }
84d1d650
L		 5886 }
5887 }
5888
5889 map->count = section_count;
5890 *pointer_to_map = map;
5891 pointer_to_map = &map->next;
5892 }
5893
5894 elf_tdata (obfd)->segment_map = map_first;
5895 return TRUE;
5896}
5897
5898/* Copy private BFD data. This copies or rewrites ELF program header
5899 information. */
5900
5901static bfd_boolean
5902copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5903{
84d1d650
L		 5904 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5905 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5906 return TRUE;
5907
5908 if (elf_tdata (ibfd)->phdr == NULL)
5909 return TRUE;
5910
5911 if (ibfd->xvec == obfd->xvec)
5912 {
cb3ff1e5
NC		 5913 /* Check to see if any sections in the input BFD
5914 covered by ELF program header have changed. */
d55ce4e2 5915 Elf_Internal_Phdr *segment;
84d1d650
L		 5916 asection *section, *osec;
5917 unsigned int i, num_segments;
5918 Elf_Internal_Shdr *this_hdr;
147d51c2
L		 5919 const struct elf_backend_data *bed;
5920
5921 bed = get_elf_backend_data (ibfd);
5922
5923 /* Regenerate the segment map if p_paddr is set to 0. */
5924 if (bed->want_p_paddr_set_to_zero)
5925 goto rewrite;
84d1d650
L		 5926
5927 /* Initialize the segment mark field. */
5928 for (section = obfd->sections; section != NULL;
5929 section = section->next)
5930 section->segment_mark = FALSE;
5931
5932 num_segments = elf_elfheader (ibfd)->e_phnum;
5933 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5934 i < num_segments;
5935 i++, segment++)
5936 {
5f6999aa
NC		 5937 /* PR binutils/3535. The Solaris linker always sets the p_paddr
5938 and p_memsz fields of special segments (DYNAMIC, INTERP) to 0
5939 which severly confuses things, so always regenerate the segment
5940 map in this case. */
5941 if (segment->p_paddr == 0
5942 && segment->p_memsz == 0
5943 && (segment->p_type == PT_INTERP || segment->p_type == PT_DYNAMIC))
cb3ff1e5 5944 goto rewrite;
5f6999aa 5945
84d1d650
L		 5946 for (section = ibfd->sections;
5947 section != NULL; section = section->next)
5948 {
5949 /* We mark the output section so that we know it comes
5950 from the input BFD. */
5951 osec = section->output_section;
5952 if (osec)
5953 osec->segment_mark = TRUE;
5954
5955 /* Check if this section is covered by the segment. */
5956 this_hdr = &(elf_section_data(section)->this_hdr);
5957 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5958 {
5959 /* FIXME: Check if its output section is changed or
5960 removed. What else do we need to check? */
5961 if (osec == NULL
5962 || section->flags != osec->flags
5963 || section->lma != osec->lma
5964 || section->vma != osec->vma
5965 || section->size != osec->size
5966 || section->rawsize != osec->rawsize
5967 || section->alignment_power != osec->alignment_power)
5968 goto rewrite;
5969 }
5970 }
5971 }
5972
cb3ff1e5 5973 /* Check to see if any output section do not come from the
84d1d650
L		 5974 input BFD. */
5975 for (section = obfd->sections; section != NULL;
5976 section = section->next)
5977 {
5978 if (section->segment_mark == FALSE)
5979 goto rewrite;
5980 else
5981 section->segment_mark = FALSE;
5982 }
5983
5984 return copy_elf_program_header (ibfd, obfd);
5985 }
5986
5987rewrite:
5988 return rewrite_elf_program_header (ibfd, obfd);
5989}
5990
ccd2ec6a
L		 5991/* Initialize private output section information from input section. */
5992
5993bfd_boolean
5994_bfd_elf_init_private_section_data (bfd *ibfd,
5995 asection *isec,
5996 bfd *obfd,
5997 asection *osec,
5998 struct bfd_link_info *link_info)
5999
6000{
6001 Elf_Internal_Shdr *ihdr, *ohdr;
6002 bfd_boolean need_group = link_info == NULL || link_info->relocatable;
6003
6004 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6005 || obfd->xvec->flavour != bfd_target_elf_flavour)
6006 return TRUE;
6007
e843e0f8 6008 /* Don't copy the output ELF section type from input if the
d3fd4074 6009 output BFD section flags have been set to something different.
e843e0f8
L		 6010 elf_fake_sections will set ELF section type based on BFD
6011 section flags. */
42bb2e33
AM		 6012 if (elf_section_type (osec) == SHT_NULL
6013 && (osec->flags == isec->flags || !osec->flags))
6014 elf_section_type (osec) = elf_section_type (isec);
d270463e
L		 6015
6016 /* FIXME: Is this correct for all OS/PROC specific flags? */
6017 elf_section_flags (osec) |= (elf_section_flags (isec)
6018 & (SHF_MASKOS | SHF_MASKPROC));
ccd2ec6a
L		 6019
6020 /* Set things up for objcopy and relocatable link. The output
6021 SHT_GROUP section will have its elf_next_in_group pointing back
6022 to the input group members. Ignore linker created group section.
6023 See elfNN_ia64_object_p in elfxx-ia64.c. */
ccd2ec6a
L		 6024 if (need_group)
6025 {
6026 if (elf_sec_group (isec) == NULL
6027 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
6028 {
6029 if (elf_section_flags (isec) & SHF_GROUP)
6030 elf_section_flags (osec) |= SHF_GROUP;
6031 elf_next_in_group (osec) = elf_next_in_group (isec);
9659de1c 6032 elf_section_data (osec)->group = elf_section_data (isec)->group;
ccd2ec6a
L		 6033 }
6034 }
6035
6036 ihdr = &elf_section_data (isec)->this_hdr;
6037
6038 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6039 don't use the output section of the linked-to section since it
6040 may be NULL at this point. */
6041 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6042 {
6043 ohdr = &elf_section_data (osec)->this_hdr;
6044 ohdr->sh_flags |= SHF_LINK_ORDER;
6045 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6046 }
6047
6048 osec->use_rela_p = isec->use_rela_p;
6049
6050 return TRUE;
6051}
6052
252b5132
RH		 6053/* Copy private section information. This copies over the entsize
6054 field, and sometimes the info field. */
6055
b34976b6 6056bfd_boolean
217aa764
AM		 6057_bfd_elf_copy_private_section_data (bfd *ibfd,
6058 asection *isec,
6059 bfd *obfd,
6060 asection *osec)
252b5132
RH		 6061{
6062 Elf_Internal_Shdr *ihdr, *ohdr;
6063
6064 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6065 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 6066 return TRUE;
252b5132 6067
252b5132
RH		 6068 ihdr = &elf_section_data (isec)->this_hdr;
6069 ohdr = &elf_section_data (osec)->this_hdr;
6070
6071 ohdr->sh_entsize = ihdr->sh_entsize;
6072
6073 if (ihdr->sh_type == SHT_SYMTAB
6074 || ihdr->sh_type == SHT_DYNSYM
6075 || ihdr->sh_type == SHT_GNU_verneed
6076 || ihdr->sh_type == SHT_GNU_verdef)
6077 ohdr->sh_info = ihdr->sh_info;
6078
ccd2ec6a
L		 6079 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6080 NULL);
252b5132
RH		 6081}
6082
80fccad2
BW		 6083/* Copy private header information. */
6084
6085bfd_boolean
6086_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6087{
30288845
AM		 6088 asection *isec;
6089
80fccad2
BW		 6090 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6091 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6092 return TRUE;
6093
6094 /* Copy over private BFD data if it has not already been copied.
6095 This must be done here, rather than in the copy_private_bfd_data
6096 entry point, because the latter is called after the section
6097 contents have been set, which means that the program headers have
6098 already been worked out. */
6099 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6100 {
6101 if (! copy_private_bfd_data (ibfd, obfd))
6102 return FALSE;
6103 }
6104
30288845
AM		 6105 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6106 but this might be wrong if we deleted the group section. */
6107 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6108 if (elf_section_type (isec) == SHT_GROUP
6109 && isec->output_section == NULL)
6110 {
6111 asection *first = elf_next_in_group (isec);
6112 asection *s = first;
6113 while (s != NULL)
6114 {
6115 if (s->output_section != NULL)
6116 {
6117 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6118 elf_group_name (s->output_section) = NULL;
6119 }
6120 s = elf_next_in_group (s);
6121 if (s == first)
6122 break;
6123 }
6124 }
6125
80fccad2
BW		 6126 return TRUE;
6127}
6128
252b5132
RH		 6129/* Copy private symbol information. If this symbol is in a section
6130 which we did not map into a BFD section, try to map the section
6131 index correctly. We use special macro definitions for the mapped
6132 section indices; these definitions are interpreted by the
6133 swap_out_syms function. */
6134
9ad5cbcf
AM		 6135#define MAP_ONESYMTAB (SHN_HIOS + 1)
6136#define MAP_DYNSYMTAB (SHN_HIOS + 2)
6137#define MAP_STRTAB (SHN_HIOS + 3)
6138#define MAP_SHSTRTAB (SHN_HIOS + 4)
6139#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 6140
b34976b6 6141bfd_boolean
217aa764
AM		 6142_bfd_elf_copy_private_symbol_data (bfd *ibfd,
6143 asymbol *isymarg,
6144 bfd *obfd,
6145 asymbol *osymarg)
252b5132
RH		 6146{
6147 elf_symbol_type *isym, *osym;
6148
6149 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6150 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 6151 return TRUE;
252b5132
RH		 6152
6153 isym = elf_symbol_from (ibfd, isymarg);
6154 osym = elf_symbol_from (obfd, osymarg);
6155
6156 if (isym != NULL
8424d8f5 6157 && isym->internal_elf_sym.st_shndx != 0
252b5132
RH		 6158 && osym != NULL
6159 && bfd_is_abs_section (isym->symbol.section))
6160 {
6161 unsigned int shndx;
6162
6163 shndx = isym->internal_elf_sym.st_shndx;
6164 if (shndx == elf_onesymtab (ibfd))
6165 shndx = MAP_ONESYMTAB;
6166 else if (shndx == elf_dynsymtab (ibfd))
6167 shndx = MAP_DYNSYMTAB;
6168 else if (shndx == elf_tdata (ibfd)->strtab_section)
6169 shndx = MAP_STRTAB;
6170 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6171 shndx = MAP_SHSTRTAB;
9ad5cbcf
AM		 6172 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6173 shndx = MAP_SYM_SHNDX;
252b5132
RH		 6174 osym->internal_elf_sym.st_shndx = shndx;
6175 }
6176
b34976b6 6177 return TRUE;
252b5132
RH		 6178}
6179
6180/* Swap out the symbols. */
6181
b34976b6 6182static bfd_boolean
217aa764
AM		 6183swap_out_syms (bfd *abfd,
6184 struct bfd_strtab_hash **sttp,
6185 int relocatable_p)
252b5132 6186{
9c5bfbb7 6187 const struct elf_backend_data *bed;
079e9a2f
AM		 6188 int symcount;
6189 asymbol **syms;
6190 struct bfd_strtab_hash *stt;
6191 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 6192 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f 6193 Elf_Internal_Shdr *symstrtab_hdr;
f075ee0c
AM		 6194 bfd_byte *outbound_syms;
6195 bfd_byte *outbound_shndx;
079e9a2f
AM		 6196 int idx;
6197 bfd_size_type amt;
174fd7f9 6198 bfd_boolean name_local_sections;
252b5132
RH		 6199
6200 if (!elf_map_symbols (abfd))
b34976b6 6201 return FALSE;
252b5132 6202
c044fabd 6203 /* Dump out the symtabs. */
079e9a2f
AM		 6204 stt = _bfd_elf_stringtab_init ();
6205 if (stt == NULL)
b34976b6 6206 return FALSE;
252b5132 6207
079e9a2f
AM		 6208 bed = get_elf_backend_data (abfd);
6209 symcount = bfd_get_symcount (abfd);
6210 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6211 symtab_hdr->sh_type = SHT_SYMTAB;
6212 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6213 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6214 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
72de5009 6215 symtab_hdr->sh_addralign = (bfd_vma) 1 << bed->s->log_file_align;
079e9a2f
AM		 6216
6217 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6218 symstrtab_hdr->sh_type = SHT_STRTAB;
6219
d0fb9a8d 6220 outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
079e9a2f 6221 if (outbound_syms == NULL)
5ed6aba4
NC		 6222 {
6223 _bfd_stringtab_free (stt);
6224 return FALSE;
6225 }
217aa764 6226 symtab_hdr->contents = outbound_syms;
252b5132 6227
9ad5cbcf
AM		 6228 outbound_shndx = NULL;
6229 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6230 if (symtab_shndx_hdr->sh_name != 0)
6231 {
6232 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
d0fb9a8d
JJ		 6233 outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6234 sizeof (Elf_External_Sym_Shndx));
9ad5cbcf 6235 if (outbound_shndx == NULL)
5ed6aba4
NC		 6236 {
6237 _bfd_stringtab_free (stt);
6238 return FALSE;
6239 }
6240
9ad5cbcf
AM		 6241 symtab_shndx_hdr->contents = outbound_shndx;
6242 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6243 symtab_shndx_hdr->sh_size = amt;
6244 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6245 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6246 }
6247
589e6347 6248 /* Now generate the data (for "contents"). */
079e9a2f
AM		 6249 {
6250 /* Fill in zeroth symbol and swap it out. */
6251 Elf_Internal_Sym sym;
6252 sym.st_name = 0;
6253 sym.st_value = 0;
6254 sym.st_size = 0;
6255 sym.st_info = 0;
6256 sym.st_other = 0;
6257 sym.st_shndx = SHN_UNDEF;
9ad5cbcf 6258 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6259 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 6260 if (outbound_shndx != NULL)
6261 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6262 }
252b5132 6263
174fd7f9
RS		 6264 name_local_sections
6265 = (bed->elf_backend_name_local_section_symbols
6266 && bed->elf_backend_name_local_section_symbols (abfd));
6267
079e9a2f
AM		 6268 syms = bfd_get_outsymbols (abfd);
6269 for (idx = 0; idx < symcount; idx++)
252b5132 6270 {
252b5132 6271 Elf_Internal_Sym sym;
079e9a2f
AM		 6272 bfd_vma value = syms[idx]->value;
6273 elf_symbol_type *type_ptr;
6274 flagword flags = syms[idx]->flags;
6275 int type;
252b5132 6276
174fd7f9
RS		 6277 if (!name_local_sections
6278 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM		 6279 {
6280 /* Local section symbols have no name. */
6281 sym.st_name = 0;
6282 }
6283 else
6284 {
6285 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6286 syms[idx]->name,
b34976b6 6287 TRUE, FALSE);
079e9a2f 6288 if (sym.st_name == (unsigned long) -1)
5ed6aba4
NC		 6289 {
6290 _bfd_stringtab_free (stt);
6291 return FALSE;
6292 }
079e9a2f 6293 }
252b5132 6294
079e9a2f 6295 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 6296
079e9a2f
AM		 6297 if ((flags & BSF_SECTION_SYM) == 0
6298 && bfd_is_com_section (syms[idx]->section))
6299 {
6300 /* ELF common symbols put the alignment into the `value' field,
6301 and the size into the `size' field. This is backwards from
6302 how BFD handles it, so reverse it here. */
6303 sym.st_size = value;
6304 if (type_ptr == NULL
6305 || type_ptr->internal_elf_sym.st_value == 0)
6306 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6307 else
6308 sym.st_value = type_ptr->internal_elf_sym.st_value;
6309 sym.st_shndx = _bfd_elf_section_from_bfd_section
6310 (abfd, syms[idx]->section);
6311 }
6312 else
6313 {
6314 asection *sec = syms[idx]->section;
cb33740c 6315 unsigned int shndx;
252b5132 6316
079e9a2f
AM		 6317 if (sec->output_section)
6318 {
6319 value += sec->output_offset;
6320 sec = sec->output_section;
6321 }
589e6347 6322
079e9a2f
AM		 6323 /* Don't add in the section vma for relocatable output. */
6324 if (! relocatable_p)
6325 value += sec->vma;
6326 sym.st_value = value;
6327 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6328
6329 if (bfd_is_abs_section (sec)
6330 && type_ptr != NULL
6331 && type_ptr->internal_elf_sym.st_shndx != 0)
6332 {
6333 /* This symbol is in a real ELF section which we did
6334 not create as a BFD section. Undo the mapping done
6335 by copy_private_symbol_data. */
6336 shndx = type_ptr->internal_elf_sym.st_shndx;
6337 switch (shndx)
6338 {
6339 case MAP_ONESYMTAB:
6340 shndx = elf_onesymtab (abfd);
6341 break;
6342 case MAP_DYNSYMTAB:
6343 shndx = elf_dynsymtab (abfd);
6344 break;
6345 case MAP_STRTAB:
6346 shndx = elf_tdata (abfd)->strtab_section;
6347 break;
6348 case MAP_SHSTRTAB:
6349 shndx = elf_tdata (abfd)->shstrtab_section;
6350 break;
9ad5cbcf
AM		 6351 case MAP_SYM_SHNDX:
6352 shndx = elf_tdata (abfd)->symtab_shndx_section;
6353 break;
079e9a2f
AM		 6354 default:
6355 break;
6356 }
6357 }
6358 else
6359 {
6360 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 6361
cb33740c 6362 if (shndx == SHN_BAD)
079e9a2f
AM		 6363 {
6364 asection *sec2;
6365
6366 /* Writing this would be a hell of a lot easier if
6367 we had some decent documentation on bfd, and
6368 knew what to expect of the library, and what to
6369 demand of applications. For example, it
6370 appears that `objcopy' might not set the
6371 section of a symbol to be a section that is
6372 actually in the output file. */
6373 sec2 = bfd_get_section_by_name (abfd, sec->name);
589e6347
NC		 6374 if (sec2 == NULL)
6375 {
6376 _bfd_error_handler (_("\
6377Unable to find equivalent output section for symbol '%s' from section '%s'"),
6378 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6379 sec->name);
811072d8 6380 bfd_set_error (bfd_error_invalid_operation);
5ed6aba4 6381 _bfd_stringtab_free (stt);
589e6347
NC		 6382 return FALSE;
6383 }
811072d8 6384
079e9a2f 6385 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
cb33740c 6386 BFD_ASSERT (shndx != SHN_BAD);
079e9a2f
AM		 6387 }
6388 }
252b5132 6389
079e9a2f
AM		 6390 sym.st_shndx = shndx;
6391 }
252b5132 6392
13ae64f3
JJ		 6393 if ((flags & BSF_THREAD_LOCAL) != 0)
6394 type = STT_TLS;
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
217aa764
AM		 7044elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
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;
252b5132 7064
252b5132
RH		 7065 filename = NULL;
7066 func = NULL;
57426232 7067 file = NULL;
252b5132 7068 low_func = 0;
57426232 7069 state = nothing_seen;
252b5132
RH		 7070
7071 for (p = symbols; *p != NULL; p++)
7072 {
7073 elf_symbol_type *q;
7074
7075 q = (elf_symbol_type *) *p;
7076
252b5132
RH		 7077 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7078 {
7079 default:
7080 break;
7081 case STT_FILE:
57426232
JB		 7082 file = &q->symbol;
7083 if (state == symbol_seen)
7084 state = file_after_symbol_seen;
7085 continue;
252b5132
RH		 7086 case STT_NOTYPE:
7087 case STT_FUNC:
6b40fcba 7088 if (bfd_get_section (&q->symbol) == section
252b5132
RH		 7089 && q->symbol.value >= low_func
7090 && q->symbol.value <= offset)
7091 {
7092 func = (asymbol *) q;
7093 low_func = q->symbol.value;
a1923858
AM		 7094 filename = NULL;
7095 if (file != NULL
7096 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7097 || state != file_after_symbol_seen))
57426232 7098 filename = bfd_asymbol_name (file);
252b5132
RH		 7099 }
7100 break;
7101 }
57426232
JB		 7102 if (state == nothing_seen)
7103 state = symbol_seen;
252b5132
RH		 7104 }
7105
7106 if (func == NULL)
b34976b6 7107 return FALSE;
252b5132 7108
d1fad7c6
NC		 7109 if (filename_ptr)
7110 *filename_ptr = filename;
7111 if (functionname_ptr)
7112 *functionname_ptr = bfd_asymbol_name (func);
7113
b34976b6 7114 return TRUE;
d1fad7c6
NC		 7115}
7116
7117/* Find the nearest line to a particular section and offset,
7118 for error reporting. */
7119
b34976b6 7120bfd_boolean
217aa764
AM		 7121_bfd_elf_find_nearest_line (bfd *abfd,
7122 asection *section,
7123 asymbol **symbols,
7124 bfd_vma offset,
7125 const char **filename_ptr,
7126 const char **functionname_ptr,
7127 unsigned int *line_ptr)
d1fad7c6 7128{
b34976b6 7129 bfd_boolean found;
d1fad7c6
NC		 7130
7131 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 7132 filename_ptr, functionname_ptr,
7133 line_ptr))
d1fad7c6
NC		 7134 {
7135 if (!*functionname_ptr)
4e8a9624
AM		 7136 elf_find_function (abfd, section, symbols, offset,
7137 *filename_ptr ? NULL : filename_ptr,
7138 functionname_ptr);
7139
b34976b6 7140 return TRUE;
d1fad7c6
NC		 7141 }
7142
7143 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 7144 filename_ptr, functionname_ptr,
7145 line_ptr, 0,
7146 &elf_tdata (abfd)->dwarf2_find_line_info))
d1fad7c6
NC		 7147 {
7148 if (!*functionname_ptr)
4e8a9624
AM		 7149 elf_find_function (abfd, section, symbols, offset,
7150 *filename_ptr ? NULL : filename_ptr,
7151 functionname_ptr);
7152
b34976b6 7153 return TRUE;
d1fad7c6
NC		 7154 }
7155
7156 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM		 7157 &found, filename_ptr,
7158 functionname_ptr, line_ptr,
7159 &elf_tdata (abfd)->line_info))
b34976b6 7160 return FALSE;
dc43ada5 7161 if (found && (*functionname_ptr || *line_ptr))
b34976b6 7162 return TRUE;
d1fad7c6
NC		 7163
7164 if (symbols == NULL)
b34976b6 7165 return FALSE;
d1fad7c6
NC		 7166
7167 if (! elf_find_function (abfd, section, symbols, offset,
4e8a9624 7168 filename_ptr, functionname_ptr))
b34976b6 7169 return FALSE;
d1fad7c6 7170
252b5132 7171 *line_ptr = 0;
b34976b6 7172 return TRUE;
252b5132
RH		 7173}
7174
5420f73d
L		 7175/* Find the line for a symbol. */
7176
7177bfd_boolean
7178_bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7179 const char **filename_ptr, unsigned int *line_ptr)
7180{
7181 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7182 filename_ptr, line_ptr, 0,
7183 &elf_tdata (abfd)->dwarf2_find_line_info);
7184}
7185
4ab527b0
FF		 7186/* After a call to bfd_find_nearest_line, successive calls to
7187 bfd_find_inliner_info can be used to get source information about
7188 each level of function inlining that terminated at the address
7189 passed to bfd_find_nearest_line. Currently this is only supported
7190 for DWARF2 with appropriate DWARF3 extensions. */
7191
7192bfd_boolean
7193_bfd_elf_find_inliner_info (bfd *abfd,
7194 const char **filename_ptr,
7195 const char **functionname_ptr,
7196 unsigned int *line_ptr)
7197{
7198 bfd_boolean found;
7199 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7200 functionname_ptr, line_ptr,
7201 & elf_tdata (abfd)->dwarf2_find_line_info);
7202 return found;
7203}
7204
252b5132 7205int
a6b96beb 7206_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
252b5132 7207{
8ded5a0f
AM		 7208 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7209 int ret = bed->s->sizeof_ehdr;
252b5132 7210
a6b96beb 7211 if (!info->relocatable)
8ded5a0f 7212 {
62d7a5f6 7213 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
8ded5a0f 7214
62d7a5f6
AM		 7215 if (phdr_size == (bfd_size_type) -1)
7216 {
7217 struct elf_segment_map *m;
7218
7219 phdr_size = 0;
7220 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7221 phdr_size += bed->s->sizeof_phdr;
8ded5a0f 7222
62d7a5f6
AM		 7223 if (phdr_size == 0)
7224 phdr_size = get_program_header_size (abfd, info);
7225 }
8ded5a0f
AM		 7226
7227 elf_tdata (abfd)->program_header_size = phdr_size;
7228 ret += phdr_size;
7229 }
7230
252b5132
RH		 7231 return ret;
7232}
7233
b34976b6 7234bfd_boolean
217aa764
AM		 7235_bfd_elf_set_section_contents (bfd *abfd,
7236 sec_ptr section,
0f867abe 7237 const void *location,
217aa764
AM		 7238 file_ptr offset,
7239 bfd_size_type count)
252b5132
RH		 7240{
7241 Elf_Internal_Shdr *hdr;
dc810e39 7242 bfd_signed_vma pos;
252b5132
RH		 7243
7244 if (! abfd->output_has_begun
217aa764 7245 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 7246 return FALSE;
252b5132
RH		 7247
7248 hdr = &elf_section_data (section)->this_hdr;
dc810e39
AM		 7249 pos = hdr->sh_offset + offset;
7250 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7251 || bfd_bwrite (location, count, abfd) != count)
b34976b6 7252 return FALSE;
252b5132 7253
b34976b6 7254 return TRUE;
252b5132
RH		 7255}
7256
7257void
217aa764
AM		 7258_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7259 arelent *cache_ptr ATTRIBUTE_UNUSED,
7260 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH		 7261{
7262 abort ();
7263}
7264
252b5132
RH		 7265/* Try to convert a non-ELF reloc into an ELF one. */
7266
b34976b6 7267bfd_boolean
217aa764 7268_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 7269{
c044fabd 7270 /* Check whether we really have an ELF howto. */
252b5132
RH		 7271
7272 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7273 {
7274 bfd_reloc_code_real_type code;
7275 reloc_howto_type *howto;
7276
7277 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 7278 equivalent ELF reloc. */
252b5132
RH		 7279
7280 if (areloc->howto->pc_relative)
7281 {
7282 switch (areloc->howto->bitsize)
7283 {
7284 case 8:
7285 code = BFD_RELOC_8_PCREL;
7286 break;
7287 case 12:
7288 code = BFD_RELOC_12_PCREL;
7289 break;
7290 case 16:
7291 code = BFD_RELOC_16_PCREL;
7292 break;
7293 case 24:
7294 code = BFD_RELOC_24_PCREL;
7295 break;
7296 case 32:
7297 code = BFD_RELOC_32_PCREL;
7298 break;
7299 case 64:
7300 code = BFD_RELOC_64_PCREL;
7301 break;
7302 default:
7303 goto fail;
7304 }
7305
7306 howto = bfd_reloc_type_lookup (abfd, code);
7307
7308 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7309 {
7310 if (howto->pcrel_offset)
7311 areloc->addend += areloc->address;
7312 else
7313 areloc->addend -= areloc->address; /* addend is unsigned!! */
7314 }
7315 }
7316 else
7317 {
7318 switch (areloc->howto->bitsize)
7319 {
7320 case 8:
7321 code = BFD_RELOC_8;
7322 break;
7323 case 14:
7324 code = BFD_RELOC_14;
7325 break;
7326 case 16:
7327 code = BFD_RELOC_16;
7328 break;
7329 case 26:
7330 code = BFD_RELOC_26;
7331 break;
7332 case 32:
7333 code = BFD_RELOC_32;
7334 break;
7335 case 64:
7336 code = BFD_RELOC_64;
7337 break;
7338 default:
7339 goto fail;
7340 }
7341
7342 howto = bfd_reloc_type_lookup (abfd, code);
7343 }
7344
7345 if (howto)
7346 areloc->howto = howto;
7347 else
7348 goto fail;
7349 }
7350
b34976b6 7351 return TRUE;
252b5132
RH		 7352
7353 fail:
7354 (*_bfd_error_handler)
d003868e
AM		 7355 (_("%B: unsupported relocation type %s"),
7356 abfd, areloc->howto->name);
252b5132 7357 bfd_set_error (bfd_error_bad_value);
b34976b6 7358 return FALSE;
252b5132
RH		 7359}
7360
b34976b6 7361bfd_boolean
217aa764 7362_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132
RH		 7363{
7364 if (bfd_get_format (abfd) == bfd_object)
7365 {
b25e3d87 7366 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
2b0f7ef9 7367 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6f140a15 7368 _bfd_dwarf2_cleanup_debug_info (abfd);
252b5132
RH		 7369 }
7370
7371 return _bfd_generic_close_and_cleanup (abfd);
7372}
7373
7374/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7375 in the relocation's offset. Thus we cannot allow any sort of sanity
7376 range-checking to interfere. There is nothing else to do in processing
7377 this reloc. */
7378
7379bfd_reloc_status_type
217aa764
AM		 7380_bfd_elf_rel_vtable_reloc_fn
7381 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 7382 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM		 7383 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7384 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH		 7385{
7386 return bfd_reloc_ok;
7387}
252b5132
RH		 7388\f
7389/* Elf core file support. Much of this only works on native
7390 toolchains, since we rely on knowing the
7391 machine-dependent procfs structure in order to pick
c044fabd 7392 out details about the corefile. */
252b5132
RH		 7393
7394#ifdef HAVE_SYS_PROCFS_H
7395# include <sys/procfs.h>
7396#endif
7397
c044fabd 7398/* FIXME: this is kinda wrong, but it's what gdb wants. */
252b5132
RH		 7399
7400static int
217aa764 7401elfcore_make_pid (bfd *abfd)
252b5132
RH		 7402{
7403 return ((elf_tdata (abfd)->core_lwpid << 16)
7404 + (elf_tdata (abfd)->core_pid));
7405}
7406
252b5132
RH		 7407/* If there isn't a section called NAME, make one, using
7408 data from SECT. Note, this function will generate a
7409 reference to NAME, so you shouldn't deallocate or
c044fabd 7410 overwrite it. */
252b5132 7411
b34976b6 7412static bfd_boolean
217aa764 7413elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 7414{
c044fabd 7415 asection *sect2;
252b5132
RH		 7416
7417 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 7418 return TRUE;
252b5132 7419
117ed4f8 7420 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
252b5132 7421 if (sect2 == NULL)
b34976b6 7422 return FALSE;
252b5132 7423
eea6121a 7424 sect2->size = sect->size;
252b5132 7425 sect2->filepos = sect->filepos;
252b5132 7426 sect2->alignment_power = sect->alignment_power;
b34976b6 7427 return TRUE;
252b5132
RH		 7428}
7429
bb0082d6
AM		 7430/* Create a pseudosection containing SIZE bytes at FILEPOS. This
7431 actually creates up to two pseudosections:
7432 - For the single-threaded case, a section named NAME, unless
7433 such a section already exists.
7434 - For the multi-threaded case, a section named "NAME/PID", where
7435 PID is elfcore_make_pid (abfd).
7436 Both pseudosections have identical contents. */
b34976b6 7437bfd_boolean
217aa764
AM		 7438_bfd_elfcore_make_pseudosection (bfd *abfd,
7439 char *name,
7440 size_t size,
7441 ufile_ptr filepos)
bb0082d6
AM		 7442{
7443 char buf[100];
7444 char *threaded_name;
d4c88bbb 7445 size_t len;
bb0082d6
AM		 7446 asection *sect;
7447
7448 /* Build the section name. */
7449
7450 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 7451 len = strlen (buf) + 1;
217aa764 7452 threaded_name = bfd_alloc (abfd, len);
bb0082d6 7453 if (threaded_name == NULL)
b34976b6 7454 return FALSE;
d4c88bbb 7455 memcpy (threaded_name, buf, len);
bb0082d6 7456
117ed4f8
AM		 7457 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7458 SEC_HAS_CONTENTS);
bb0082d6 7459 if (sect == NULL)
b34976b6 7460 return FALSE;
eea6121a 7461 sect->size = size;
bb0082d6 7462 sect->filepos = filepos;
bb0082d6
AM		 7463 sect->alignment_power = 2;
7464
936e320b 7465 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM		 7466}
7467
252b5132 7468/* prstatus_t exists on:
4a938328 7469 solaris 2.5+
252b5132
RH		 7470 linux 2.[01] + glibc
7471 unixware 4.2
7472*/
7473
7474#if defined (HAVE_PRSTATUS_T)
a7b97311 7475
b34976b6 7476static bfd_boolean
217aa764 7477elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 7478{
eea6121a 7479 size_t size;
7ee38065 7480 int offset;
252b5132 7481
4a938328
MS		 7482 if (note->descsz == sizeof (prstatus_t))
7483 {
7484 prstatus_t prstat;
252b5132 7485
eea6121a 7486 size = sizeof (prstat.pr_reg);
7ee38065 7487 offset = offsetof (prstatus_t, pr_reg);
4a938328 7488 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 7489
fa49d224
NC		 7490 /* Do not overwrite the core signal if it
7491 has already been set by another thread. */
7492 if (elf_tdata (abfd)->core_signal == 0)
7493 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4a938328 7494 elf_tdata (abfd)->core_pid = prstat.pr_pid;
252b5132 7495
4a938328
MS		 7496 /* pr_who exists on:
7497 solaris 2.5+
7498 unixware 4.2
7499 pr_who doesn't exist on:
7500 linux 2.[01]
7501 */
252b5132 7502#if defined (HAVE_PRSTATUS_T_PR_WHO)
4a938328 7503 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
252b5132 7504#endif
4a938328 7505 }
7ee38065 7506#if defined (HAVE_PRSTATUS32_T)
4a938328
MS		 7507 else if (note->descsz == sizeof (prstatus32_t))
7508 {
7509 /* 64-bit host, 32-bit corefile */
7510 prstatus32_t prstat;
7511
eea6121a 7512 size = sizeof (prstat.pr_reg);
7ee38065 7513 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS		 7514 memcpy (&prstat, note->descdata, sizeof (prstat));
7515
fa49d224
NC		 7516 /* Do not overwrite the core signal if it
7517 has already been set by another thread. */
7518 if (elf_tdata (abfd)->core_signal == 0)
7519 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4a938328
MS		 7520 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7521
7522 /* pr_who exists on:
7523 solaris 2.5+
7524 unixware 4.2
7525 pr_who doesn't exist on:
7526 linux 2.[01]
7527 */
7ee38065 7528#if defined (HAVE_PRSTATUS32_T_PR_WHO)
4a938328
MS		 7529 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7530#endif
7531 }
7ee38065 7532#endif /* HAVE_PRSTATUS32_T */
4a938328
MS		 7533 else
7534 {
7535 /* Fail - we don't know how to handle any other
7536 note size (ie. data object type). */
b34976b6 7537 return TRUE;
4a938328 7538 }
252b5132 7539
bb0082d6 7540 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 7541 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 7542 size, note->descpos + offset);
252b5132
RH		 7543}
7544#endif /* defined (HAVE_PRSTATUS_T) */
7545
bb0082d6 7546/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 7547static bfd_boolean
217aa764
AM		 7548elfcore_make_note_pseudosection (bfd *abfd,
7549 char *name,
7550 Elf_Internal_Note *note)
252b5132 7551{
936e320b
AM		 7552 return _bfd_elfcore_make_pseudosection (abfd, name,
7553 note->descsz, note->descpos);
252b5132
RH		 7554}
7555
ff08c6bb
JB		 7556/* There isn't a consistent prfpregset_t across platforms,
7557 but it doesn't matter, because we don't have to pick this
c044fabd
KH		 7558 data structure apart. */
7559
b34976b6 7560static bfd_boolean
217aa764 7561elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 7562{
7563 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7564}
7565
ff08c6bb 7566/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
971d4640 7567 type of NT_PRXFPREG. Just include the whole note's contents
ff08c6bb 7568 literally. */
c044fabd 7569
b34976b6 7570static bfd_boolean
217aa764 7571elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 7572{
7573 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7574}
7575
97753bd5
AM		 7576static bfd_boolean
7577elfcore_grok_ppc_vmx (bfd *abfd, Elf_Internal_Note *note)
7578{
7579 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vmx", note);
7580}
7581
89eeb0bc
LM		 7582static bfd_boolean
7583elfcore_grok_ppc_vsx (bfd *abfd, Elf_Internal_Note *note)
7584{
7585 return elfcore_make_note_pseudosection (abfd, ".reg-ppc-vsx", note);
7586}
97753bd5 7587
252b5132 7588#if defined (HAVE_PRPSINFO_T)
4a938328 7589typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 7590#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 7591typedef prpsinfo32_t elfcore_psinfo32_t;
7592#endif
252b5132
RH		 7593#endif
7594
7595#if defined (HAVE_PSINFO_T)
4a938328 7596typedef psinfo_t elfcore_psinfo_t;
7ee38065 7597#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 7598typedef psinfo32_t elfcore_psinfo32_t;
7599#endif
252b5132
RH		 7600#endif
7601
252b5132
RH		 7602/* return a malloc'ed copy of a string at START which is at
7603 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 7604 the copy will always have a terminating '\0'. */
252b5132 7605
936e320b 7606char *
217aa764 7607_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 7608{
dc810e39 7609 char *dups;
c044fabd 7610 char *end = memchr (start, '\0', max);
dc810e39 7611 size_t len;
252b5132
RH		 7612
7613 if (end == NULL)
7614 len = max;
7615 else
7616 len = end - start;
7617
217aa764 7618 dups = bfd_alloc (abfd, len + 1);
dc810e39 7619 if (dups == NULL)
252b5132
RH		 7620 return NULL;
7621
dc810e39
AM		 7622 memcpy (dups, start, len);
7623 dups[len] = '\0';
252b5132 7624
dc810e39 7625 return dups;
252b5132
RH		 7626}
7627
bb0082d6 7628#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 7629static bfd_boolean
217aa764 7630elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 7631{
4a938328
MS		 7632 if (note->descsz == sizeof (elfcore_psinfo_t))
7633 {
7634 elfcore_psinfo_t psinfo;
252b5132 7635
7ee38065 7636 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 7637
4a938328 7638 elf_tdata (abfd)->core_program
936e320b
AM		 7639 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7640 sizeof (psinfo.pr_fname));
252b5132 7641
4a938328 7642 elf_tdata (abfd)->core_command
936e320b
AM		 7643 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7644 sizeof (psinfo.pr_psargs));
4a938328 7645 }
7ee38065 7646#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS		 7647 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7648 {
7649 /* 64-bit host, 32-bit corefile */
7650 elfcore_psinfo32_t psinfo;
7651
7ee38065 7652 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 7653
4a938328 7654 elf_tdata (abfd)->core_program
936e320b
AM		 7655 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7656 sizeof (psinfo.pr_fname));
4a938328
MS		 7657
7658 elf_tdata (abfd)->core_command
936e320b
AM		 7659 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7660 sizeof (psinfo.pr_psargs));
4a938328
MS		 7661 }
7662#endif
7663
7664 else
7665 {
7666 /* Fail - we don't know how to handle any other
7667 note size (ie. data object type). */
b34976b6 7668 return TRUE;
4a938328 7669 }
252b5132
RH		 7670
7671 /* Note that for some reason, a spurious space is tacked
7672 onto the end of the args in some (at least one anyway)
c044fabd 7673 implementations, so strip it off if it exists. */
252b5132
RH		 7674
7675 {
c044fabd 7676 char *command = elf_tdata (abfd)->core_command;
252b5132
RH		 7677 int n = strlen (command);
7678
7679 if (0 < n && command[n - 1] == ' ')
7680 command[n - 1] = '\0';
7681 }
7682
b34976b6 7683 return TRUE;
252b5132
RH		 7684}
7685#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7686
252b5132 7687#if defined (HAVE_PSTATUS_T)
b34976b6 7688static bfd_boolean
217aa764 7689elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 7690{
f572a39d
AM		 7691 if (note->descsz == sizeof (pstatus_t)
7692#if defined (HAVE_PXSTATUS_T)
7693 || note->descsz == sizeof (pxstatus_t)
7694#endif
7695 )
4a938328
MS		 7696 {
7697 pstatus_t pstat;
252b5132 7698
4a938328 7699 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 7700
4a938328
MS		 7701 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7702 }
7ee38065 7703#if defined (HAVE_PSTATUS32_T)
4a938328
MS		 7704 else if (note->descsz == sizeof (pstatus32_t))
7705 {
7706 /* 64-bit host, 32-bit corefile */
7707 pstatus32_t pstat;
252b5132 7708
4a938328 7709 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 7710
4a938328
MS		 7711 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7712 }
7713#endif
252b5132
RH		 7714 /* Could grab some more details from the "representative"
7715 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 7716 NT_LWPSTATUS note, presumably. */
252b5132 7717
b34976b6 7718 return TRUE;
252b5132
RH		 7719}
7720#endif /* defined (HAVE_PSTATUS_T) */
7721
252b5132 7722#if defined (HAVE_LWPSTATUS_T)
b34976b6 7723static bfd_boolean
217aa764 7724elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH		 7725{
7726 lwpstatus_t lwpstat;
7727 char buf[100];
c044fabd 7728 char *name;
d4c88bbb 7729 size_t len;
c044fabd 7730 asection *sect;
252b5132 7731
f572a39d
AM		 7732 if (note->descsz != sizeof (lwpstat)
7733#if defined (HAVE_LWPXSTATUS_T)
7734 && note->descsz != sizeof (lwpxstatus_t)
7735#endif
7736 )
b34976b6 7737 return TRUE;
252b5132
RH		 7738
7739 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7740
7741 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7742 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7743
c044fabd 7744 /* Make a ".reg/999" section. */
252b5132
RH		 7745
7746 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 7747 len = strlen (buf) + 1;
217aa764 7748 name = bfd_alloc (abfd, len);
252b5132 7749 if (name == NULL)
b34976b6 7750 return FALSE;
d4c88bbb 7751 memcpy (name, buf, len);
252b5132 7752
117ed4f8 7753 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 7754 if (sect == NULL)
b34976b6 7755 return FALSE;
252b5132
RH		 7756
7757#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 7758 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH		 7759 sect->filepos = note->descpos
7760 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7761#endif
7762
7763#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 7764 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH		 7765 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7766#endif
7767
252b5132
RH		 7768 sect->alignment_power = 2;
7769
7770 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 7771 return FALSE;
252b5132
RH		 7772
7773 /* Make a ".reg2/999" section */
7774
7775 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 7776 len = strlen (buf) + 1;
217aa764 7777 name = bfd_alloc (abfd, len);
252b5132 7778 if (name == NULL)
b34976b6 7779 return FALSE;
d4c88bbb 7780 memcpy (name, buf, len);
252b5132 7781
117ed4f8 7782 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 7783 if (sect == NULL)
b34976b6 7784 return FALSE;
252b5132
RH		 7785
7786#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 7787 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH		 7788 sect->filepos = note->descpos
7789 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7790#endif
7791
7792#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 7793 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH		 7794 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7795#endif
7796
252b5132
RH		 7797 sect->alignment_power = 2;
7798
936e320b 7799 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH		 7800}
7801#endif /* defined (HAVE_LWPSTATUS_T) */
7802
b34976b6 7803static bfd_boolean
217aa764 7804elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC		 7805{
7806 char buf[30];
c044fabd 7807 char *name;
d4c88bbb 7808 size_t len;
c044fabd 7809 asection *sect;
4a6636fb
PA		 7810 int type;
7811 int is_active_thread;
7812 bfd_vma base_addr;
16e9c715 7813
4a6636fb 7814 if (note->descsz < 728)
b34976b6 7815 return TRUE;
16e9c715 7816
4a6636fb
PA		 7817 if (! CONST_STRNEQ (note->namedata, "win32"))
7818 return TRUE;
7819
7820 type = bfd_get_32 (abfd, note->descdata);
c044fabd 7821
4a6636fb 7822 switch (type)
16e9c715 7823 {
4a6636fb 7824 case 1 /* NOTE_INFO_PROCESS */:
16e9c715 7825 /* FIXME: need to add ->core_command. */
4a6636fb
PA		 7826 /* process_info.pid */
7827 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 8);
7828 /* process_info.signal */
7829 elf_tdata (abfd)->core_signal = bfd_get_32 (abfd, note->descdata + 12);
c044fabd 7830 break;
16e9c715 7831
4a6636fb 7832 case 2 /* NOTE_INFO_THREAD */:
16e9c715 7833 /* Make a ".reg/999" section. */
4a6636fb
PA		 7834 /* thread_info.tid */
7835 sprintf (buf, ".reg/%ld", (long) bfd_get_32 (abfd, note->descdata + 8));
c044fabd 7836
d4c88bbb 7837 len = strlen (buf) + 1;
217aa764 7838 name = bfd_alloc (abfd, len);
16e9c715 7839 if (name == NULL)
b34976b6 7840 return FALSE;
c044fabd 7841
d4c88bbb 7842 memcpy (name, buf, len);
16e9c715 7843
117ed4f8 7844 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
16e9c715 7845 if (sect == NULL)
b34976b6 7846 return FALSE;
c044fabd 7847
4a6636fb
PA		 7848 /* sizeof (thread_info.thread_context) */
7849 sect->size = 716;
7850 /* offsetof (thread_info.thread_context) */
7851 sect->filepos = note->descpos + 12;
16e9c715
NC		 7852 sect->alignment_power = 2;
7853
4a6636fb
PA		 7854 /* thread_info.is_active_thread */
7855 is_active_thread = bfd_get_32 (abfd, note->descdata + 8);
7856
7857 if (is_active_thread)
16e9c715 7858 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 7859 return FALSE;
16e9c715
NC		 7860 break;
7861
4a6636fb 7862 case 3 /* NOTE_INFO_MODULE */:
16e9c715 7863 /* Make a ".module/xxxxxxxx" section. */
4a6636fb
PA		 7864 /* module_info.base_address */
7865 base_addr = bfd_get_32 (abfd, note->descdata + 4);
0af1713e 7866 sprintf (buf, ".module/%08lx", (unsigned long) base_addr);
c044fabd 7867
d4c88bbb 7868 len = strlen (buf) + 1;
217aa764 7869 name = bfd_alloc (abfd, len);
16e9c715 7870 if (name == NULL)
b34976b6 7871 return FALSE;
c044fabd 7872
d4c88bbb 7873 memcpy (name, buf, len);
252b5132 7874
117ed4f8 7875 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
c044fabd 7876
16e9c715 7877 if (sect == NULL)
b34976b6 7878 return FALSE;
c044fabd 7879
eea6121a 7880 sect->size = note->descsz;
16e9c715 7881 sect->filepos = note->descpos;
16e9c715
NC		 7882 sect->alignment_power = 2;
7883 break;
7884
7885 default:
b34976b6 7886 return TRUE;
16e9c715
NC		 7887 }
7888
b34976b6 7889 return TRUE;
16e9c715 7890}
252b5132 7891
b34976b6 7892static bfd_boolean
217aa764 7893elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 7894{
9c5bfbb7 7895 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 7896
252b5132
RH		 7897 switch (note->type)
7898 {
7899 default:
b34976b6 7900 return TRUE;
252b5132 7901
252b5132 7902 case NT_PRSTATUS:
bb0082d6
AM		 7903 if (bed->elf_backend_grok_prstatus)
7904 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 7905 return TRUE;
bb0082d6 7906#if defined (HAVE_PRSTATUS_T)
252b5132 7907 return elfcore_grok_prstatus (abfd, note);
bb0082d6 7908#else
b34976b6 7909 return TRUE;
252b5132
RH		 7910#endif
7911
7912#if defined (HAVE_PSTATUS_T)
7913 case NT_PSTATUS:
7914 return elfcore_grok_pstatus (abfd, note);
7915#endif
7916
7917#if defined (HAVE_LWPSTATUS_T)
7918 case NT_LWPSTATUS:
7919 return elfcore_grok_lwpstatus (abfd, note);
7920#endif
7921
7922 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7923 return elfcore_grok_prfpreg (abfd, note);
7924
c044fabd 7925 case NT_WIN32PSTATUS:
16e9c715 7926 return elfcore_grok_win32pstatus (abfd, note);
16e9c715 7927
c044fabd 7928 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK		 7929 if (note->namesz == 6
7930 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB		 7931 return elfcore_grok_prxfpreg (abfd, note);
7932 else
b34976b6 7933 return TRUE;
ff08c6bb 7934
97753bd5
AM		 7935 case NT_PPC_VMX:
7936 if (note->namesz == 6
7937 && strcmp (note->namedata, "LINUX") == 0)
7938 return elfcore_grok_ppc_vmx (abfd, note);
7939 else
7940 return TRUE;
7941
89eeb0bc
LM		 7942 case NT_PPC_VSX:
7943 if (note->namesz == 6
7944 && strcmp (note->namedata, "LINUX") == 0)
7945 return elfcore_grok_ppc_vsx (abfd, note);
7946 else
7947 return TRUE;
7948
252b5132
RH		 7949 case NT_PRPSINFO:
7950 case NT_PSINFO:
bb0082d6
AM		 7951 if (bed->elf_backend_grok_psinfo)
7952 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 7953 return TRUE;
bb0082d6 7954#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 7955 return elfcore_grok_psinfo (abfd, note);
bb0082d6 7956#else
b34976b6 7957 return TRUE;
252b5132 7958#endif
3333a7c3
RM		 7959
7960 case NT_AUXV:
7961 {
117ed4f8
AM		 7962 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7963 SEC_HAS_CONTENTS);
3333a7c3
RM		 7964
7965 if (sect == NULL)
7966 return FALSE;
eea6121a 7967 sect->size = note->descsz;
3333a7c3 7968 sect->filepos = note->descpos;
3333a7c3
RM		 7969 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7970
7971 return TRUE;
7972 }
252b5132
RH		 7973 }
7974}
7975
718175fa
JK		 7976static bfd_boolean
7977elfobj_grok_gnu_build_id (bfd *abfd, Elf_Internal_Note *note)
7978{
7979 elf_tdata (abfd)->build_id_size = note->descsz;
7980 elf_tdata (abfd)->build_id = bfd_alloc (abfd, note->descsz);
7981 if (elf_tdata (abfd)->build_id == NULL)
7982 return FALSE;
7983
7984 memcpy (elf_tdata (abfd)->build_id, note->descdata, note->descsz);
7985
7986 return TRUE;
7987}
7988
7989static bfd_boolean
7990elfobj_grok_gnu_note (bfd *abfd, Elf_Internal_Note *note)
7991{
7992 switch (note->type)
7993 {
7994 default:
7995 return TRUE;
7996
7997 case NT_GNU_BUILD_ID:
7998 return elfobj_grok_gnu_build_id (abfd, note);
7999 }
8000}
8001
b34976b6 8002static bfd_boolean
217aa764 8003elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM		 8004{
8005 char *cp;
8006
8007 cp = strchr (note->namedata, '@');
8008 if (cp != NULL)
8009 {
d2b64500 8010 *lwpidp = atoi(cp + 1);
b34976b6 8011 return TRUE;
50b2bdb7 8012 }
b34976b6 8013 return FALSE;
50b2bdb7
AM		 8014}
8015
b34976b6 8016static bfd_boolean
217aa764 8017elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7 8018{
50b2bdb7
AM		 8019 /* Signal number at offset 0x08. */
8020 elf_tdata (abfd)->core_signal
8021 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
8022
8023 /* Process ID at offset 0x50. */
8024 elf_tdata (abfd)->core_pid
8025 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
8026
8027 /* Command name at 0x7c (max 32 bytes, including nul). */
8028 elf_tdata (abfd)->core_command
8029 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
8030
7720ba9f
MK		 8031 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
8032 note);
50b2bdb7
AM		 8033}
8034
b34976b6 8035static bfd_boolean
217aa764 8036elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 8037{
8038 int lwp;
8039
8040 if (elfcore_netbsd_get_lwpid (note, &lwp))
8041 elf_tdata (abfd)->core_lwpid = lwp;
8042
b4db1224 8043 if (note->type == NT_NETBSDCORE_PROCINFO)
50b2bdb7
AM		 8044 {
8045 /* NetBSD-specific core "procinfo". Note that we expect to
08a40648
AM		 8046 find this note before any of the others, which is fine,
8047 since the kernel writes this note out first when it
8048 creates a core file. */
47d9a591 8049
50b2bdb7
AM		 8050 return elfcore_grok_netbsd_procinfo (abfd, note);
8051 }
8052
b4db1224
JT		 8053 /* As of Jan 2002 there are no other machine-independent notes
8054 defined for NetBSD core files. If the note type is less
8055 than the start of the machine-dependent note types, we don't
8056 understand it. */
47d9a591 8057
b4db1224 8058 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 8059 return TRUE;
50b2bdb7
AM		 8060
8061
8062 switch (bfd_get_arch (abfd))
8063 {
08a40648
AM		 8064 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
8065 PT_GETFPREGS == mach+2. */
50b2bdb7
AM		 8066
8067 case bfd_arch_alpha:
8068 case bfd_arch_sparc:
8069 switch (note->type)
08a40648
AM		 8070 {
8071 case NT_NETBSDCORE_FIRSTMACH+0:
8072 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 8073
08a40648
AM		 8074 case NT_NETBSDCORE_FIRSTMACH+2:
8075 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 8076
08a40648
AM		 8077 default:
8078 return TRUE;
8079 }
50b2bdb7 8080
08a40648
AM		 8081 /* On all other arch's, PT_GETREGS == mach+1 and
8082 PT_GETFPREGS == mach+3. */
50b2bdb7
AM		 8083
8084 default:
8085 switch (note->type)
08a40648
AM		 8086 {
8087 case NT_NETBSDCORE_FIRSTMACH+1:
8088 return elfcore_make_note_pseudosection (abfd, ".reg", note);
50b2bdb7 8089
08a40648
AM		 8090 case NT_NETBSDCORE_FIRSTMACH+3:
8091 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
50b2bdb7 8092
08a40648
AM		 8093 default:
8094 return TRUE;
8095 }
50b2bdb7
AM		 8096 }
8097 /* NOTREACHED */
8098}
8099
07c6e936 8100static bfd_boolean
d3fd4074 8101elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
07c6e936
NC		 8102{
8103 void *ddata = note->descdata;
8104 char buf[100];
8105 char *name;
8106 asection *sect;
f8843e87
AM		 8107 short sig;
8108 unsigned flags;
07c6e936
NC		 8109
8110 /* nto_procfs_status 'pid' field is at offset 0. */
8111 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8112
f8843e87
AM		 8113 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8114 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8115
8116 /* nto_procfs_status 'flags' field is at offset 8. */
8117 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC		 8118
8119 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM		 8120 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8121 {
8122 elf_tdata (abfd)->core_signal = sig;
8123 elf_tdata (abfd)->core_lwpid = *tid;
8124 }
07c6e936 8125
f8843e87
AM		 8126 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8127 do not come from signals so we make sure we set the current
8128 thread just in case. */
8129 if (flags & 0x00000080)
8130 elf_tdata (abfd)->core_lwpid = *tid;
07c6e936
NC		 8131
8132 /* Make a ".qnx_core_status/%d" section. */
d3fd4074 8133 sprintf (buf, ".qnx_core_status/%ld", *tid);
07c6e936 8134
217aa764 8135 name = bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 8136 if (name == NULL)
8137 return FALSE;
8138 strcpy (name, buf);
8139
117ed4f8 8140 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 8141 if (sect == NULL)
8142 return FALSE;
8143
eea6121a 8144 sect->size = note->descsz;
07c6e936 8145 sect->filepos = note->descpos;
07c6e936
NC		 8146 sect->alignment_power = 2;
8147
8148 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8149}
8150
8151static bfd_boolean
d69f560c
KW		 8152elfcore_grok_nto_regs (bfd *abfd,
8153 Elf_Internal_Note *note,
d3fd4074 8154 long tid,
d69f560c 8155 char *base)
07c6e936
NC		 8156{
8157 char buf[100];
8158 char *name;
8159 asection *sect;
8160
d69f560c 8161 /* Make a "(base)/%d" section. */
d3fd4074 8162 sprintf (buf, "%s/%ld", base, tid);
07c6e936 8163
217aa764 8164 name = bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 8165 if (name == NULL)
8166 return FALSE;
8167 strcpy (name, buf);
8168
117ed4f8 8169 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 8170 if (sect == NULL)
8171 return FALSE;
8172
eea6121a 8173 sect->size = note->descsz;
07c6e936 8174 sect->filepos = note->descpos;
07c6e936
NC		 8175 sect->alignment_power = 2;
8176
f8843e87
AM		 8177 /* This is the current thread. */
8178 if (elf_tdata (abfd)->core_lwpid == tid)
d69f560c 8179 return elfcore_maybe_make_sect (abfd, base, sect);
f8843e87
AM		 8180
8181 return TRUE;
07c6e936
NC		 8182}
8183
8184#define BFD_QNT_CORE_INFO 7
8185#define BFD_QNT_CORE_STATUS 8
8186#define BFD_QNT_CORE_GREG 9
8187#define BFD_QNT_CORE_FPREG 10
8188
8189static bfd_boolean
217aa764 8190elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC		 8191{
8192 /* Every GREG section has a STATUS section before it. Store the
811072d8 8193 tid from the previous call to pass down to the next gregs
07c6e936 8194 function. */
d3fd4074 8195 static long tid = 1;
07c6e936
NC		 8196
8197 switch (note->type)
8198 {
d69f560c
KW		 8199 case BFD_QNT_CORE_INFO:
8200 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8201 case BFD_QNT_CORE_STATUS:
8202 return elfcore_grok_nto_status (abfd, note, &tid);
8203 case BFD_QNT_CORE_GREG:
8204 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8205 case BFD_QNT_CORE_FPREG:
8206 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8207 default:
8208 return TRUE;
07c6e936
NC		 8209 }
8210}
8211
b15fa79e
AM		 8212static bfd_boolean
8213elfcore_grok_spu_note (bfd *abfd, Elf_Internal_Note *note)
8214{
8215 char *name;
8216 asection *sect;
8217 size_t len;
8218
8219 /* Use note name as section name. */
8220 len = note->namesz;
8221 name = bfd_alloc (abfd, len);
8222 if (name == NULL)
8223 return FALSE;
8224 memcpy (name, note->namedata, len);
8225 name[len - 1] = '\0';
8226
8227 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
8228 if (sect == NULL)
8229 return FALSE;
8230
8231 sect->size = note->descsz;
8232 sect->filepos = note->descpos;
8233 sect->alignment_power = 1;
8234
8235 return TRUE;
8236}
8237
7c76fa91
MS		 8238/* Function: elfcore_write_note
8239
47d9a591 8240 Inputs:
a39f3346 8241 buffer to hold note, and current size of buffer
7c76fa91
MS		 8242 name of note
8243 type of note
8244 data for note
8245 size of data for note
8246
a39f3346
AM		 8247 Writes note to end of buffer. ELF64 notes are written exactly as
8248 for ELF32, despite the current (as of 2006) ELF gabi specifying
8249 that they ought to have 8-byte namesz and descsz field, and have
8250 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8251
7c76fa91 8252 Return:
a39f3346 8253 Pointer to realloc'd buffer, *BUFSIZ updated. */
7c76fa91
MS		 8254
8255char *
a39f3346 8256elfcore_write_note (bfd *abfd,
217aa764 8257 char *buf,
a39f3346 8258 int *bufsiz,
217aa764 8259 const char *name,
a39f3346 8260 int type,
217aa764 8261 const void *input,
a39f3346 8262 int size)
7c76fa91
MS		 8263{
8264 Elf_External_Note *xnp;
d4c88bbb 8265 size_t namesz;
d4c88bbb 8266 size_t newspace;
a39f3346 8267 char *dest;
7c76fa91 8268
d4c88bbb 8269 namesz = 0;
d4c88bbb 8270 if (name != NULL)
a39f3346 8271 namesz = strlen (name) + 1;
d4c88bbb 8272
a39f3346 8273 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
d4c88bbb 8274
a39f3346 8275 buf = realloc (buf, *bufsiz + newspace);
14b1c01e
AM		 8276 if (buf == NULL)
8277 return buf;
a39f3346 8278 dest = buf + *bufsiz;
7c76fa91
MS		 8279 *bufsiz += newspace;
8280 xnp = (Elf_External_Note *) dest;
8281 H_PUT_32 (abfd, namesz, xnp->namesz);
8282 H_PUT_32 (abfd, size, xnp->descsz);
8283 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM		 8284 dest = xnp->name;
8285 if (name != NULL)
8286 {
8287 memcpy (dest, name, namesz);
8288 dest += namesz;
a39f3346 8289 while (namesz & 3)
d4c88bbb
AM		 8290 {
8291 *dest++ = '\0';
a39f3346 8292 ++namesz;
d4c88bbb
AM		 8293 }
8294 }
8295 memcpy (dest, input, size);
a39f3346
AM		 8296 dest += size;
8297 while (size & 3)
8298 {
8299 *dest++ = '\0';
8300 ++size;
8301 }
8302 return buf;
7c76fa91
MS		 8303}
8304
8305#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8306char *
217aa764
AM		 8307elfcore_write_prpsinfo (bfd *abfd,
8308 char *buf,
8309 int *bufsiz,
8310 const char *fname,
8311 const char *psargs)
7c76fa91 8312{
183e98be
AM		 8313 const char *note_name = "CORE";
8314 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8315
8316 if (bed->elf_backend_write_core_note != NULL)
8317 {
8318 char *ret;
8319 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8320 NT_PRPSINFO, fname, psargs);
8321 if (ret != NULL)
8322 return ret;
8323 }
7c76fa91 8324
183e98be
AM		 8325#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
8326 if (bed->s->elfclass == ELFCLASS32)
8327 {
8328#if defined (HAVE_PSINFO32_T)
8329 psinfo32_t data;
8330 int note_type = NT_PSINFO;
8331#else
8332 prpsinfo32_t data;
8333 int note_type = NT_PRPSINFO;
8334#endif
8335
8336 memset (&data, 0, sizeof (data));
8337 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8338 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8339 return elfcore_write_note (abfd, buf, bufsiz,
8340 note_name, note_type, &data, sizeof (data));
8341 }
8342 else
8343#endif
8344 {
7c76fa91 8345#if defined (HAVE_PSINFO_T)
183e98be
AM		 8346 psinfo_t data;
8347 int note_type = NT_PSINFO;
7c76fa91 8348#else
183e98be
AM		 8349 prpsinfo_t data;
8350 int note_type = NT_PRPSINFO;
7c76fa91
MS		 8351#endif
8352
183e98be
AM		 8353 memset (&data, 0, sizeof (data));
8354 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8355 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
8356 return elfcore_write_note (abfd, buf, bufsiz,
8357 note_name, note_type, &data, sizeof (data));
8358 }
7c76fa91
MS		 8359}
8360#endif /* PSINFO_T or PRPSINFO_T */
8361
8362#if defined (HAVE_PRSTATUS_T)
8363char *
217aa764
AM		 8364elfcore_write_prstatus (bfd *abfd,
8365 char *buf,
8366 int *bufsiz,
8367 long pid,
8368 int cursig,
8369 const void *gregs)
7c76fa91 8370{
183e98be
AM		 8371 const char *note_name = "CORE";
8372 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 8373
183e98be
AM		 8374 if (bed->elf_backend_write_core_note != NULL)
8375 {
8376 char *ret;
8377 ret = (*bed->elf_backend_write_core_note) (abfd, buf, bufsiz,
8378 NT_PRSTATUS,
8379 pid, cursig, gregs);
8380 if (ret != NULL)
8381 return ret;
8382 }
8383
8384#if defined (HAVE_PRSTATUS32_T)
8385 if (bed->s->elfclass == ELFCLASS32)
8386 {
8387 prstatus32_t prstat;
8388
8389 memset (&prstat, 0, sizeof (prstat));
8390 prstat.pr_pid = pid;
8391 prstat.pr_cursig = cursig;
8392 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8393 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8394 NT_PRSTATUS, &prstat, sizeof (prstat));
8395 }
8396 else
8397#endif
8398 {
8399 prstatus_t prstat;
8400
8401 memset (&prstat, 0, sizeof (prstat));
8402 prstat.pr_pid = pid;
8403 prstat.pr_cursig = cursig;
8404 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
8405 return elfcore_write_note (abfd, buf, bufsiz, note_name,
8406 NT_PRSTATUS, &prstat, sizeof (prstat));
8407 }
7c76fa91
MS		 8408}
8409#endif /* HAVE_PRSTATUS_T */
8410
51316059
MS		 8411#if defined (HAVE_LWPSTATUS_T)
8412char *
217aa764
AM		 8413elfcore_write_lwpstatus (bfd *abfd,
8414 char *buf,
8415 int *bufsiz,
8416 long pid,
8417 int cursig,
8418 const void *gregs)
51316059
MS		 8419{
8420 lwpstatus_t lwpstat;
183e98be 8421 const char *note_name = "CORE";
51316059
MS		 8422
8423 memset (&lwpstat, 0, sizeof (lwpstat));
8424 lwpstat.pr_lwpid = pid >> 16;
8425 lwpstat.pr_cursig = cursig;
8426#if defined (HAVE_LWPSTATUS_T_PR_REG)
8427 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8428#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8429#if !defined(gregs)
8430 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8431 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8432#else
8433 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8434 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8435#endif
8436#endif
47d9a591 8437 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 8438 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8439}
8440#endif /* HAVE_LWPSTATUS_T */
8441
7c76fa91
MS		 8442#if defined (HAVE_PSTATUS_T)
8443char *
217aa764
AM		 8444elfcore_write_pstatus (bfd *abfd,
8445 char *buf,
8446 int *bufsiz,
8447 long pid,
6c10990d
NC		 8448 int cursig ATTRIBUTE_UNUSED,
8449 const void *gregs ATTRIBUTE_UNUSED)
7c76fa91 8450{
183e98be
AM		 8451 const char *note_name = "CORE";
8452#if defined (HAVE_PSTATUS32_T)
8453 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7c76fa91 8454
183e98be
AM		 8455 if (bed->s->elfclass == ELFCLASS32)
8456 {
8457 pstatus32_t pstat;
8458
8459 memset (&pstat, 0, sizeof (pstat));
8460 pstat.pr_pid = pid & 0xffff;
8461 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8462 NT_PSTATUS, &pstat, sizeof (pstat));
8463 return buf;
8464 }
8465 else
8466#endif
8467 {
8468 pstatus_t pstat;
8469
8470 memset (&pstat, 0, sizeof (pstat));
8471 pstat.pr_pid = pid & 0xffff;
8472 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
8473 NT_PSTATUS, &pstat, sizeof (pstat));
8474 return buf;
8475 }
7c76fa91
MS		 8476}
8477#endif /* HAVE_PSTATUS_T */
8478
8479char *
217aa764
AM		 8480elfcore_write_prfpreg (bfd *abfd,
8481 char *buf,
8482 int *bufsiz,
8483 const void *fpregs,
8484 int size)
7c76fa91 8485{
183e98be 8486 const char *note_name = "CORE";
47d9a591 8487 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 8488 note_name, NT_FPREGSET, fpregs, size);
8489}
8490
8491char *
217aa764
AM		 8492elfcore_write_prxfpreg (bfd *abfd,
8493 char *buf,
8494 int *bufsiz,
8495 const void *xfpregs,
8496 int size)
7c76fa91
MS		 8497{
8498 char *note_name = "LINUX";
47d9a591 8499 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 8500 note_name, NT_PRXFPREG, xfpregs, size);
8501}
8502
97753bd5
AM		 8503char *
8504elfcore_write_ppc_vmx (bfd *abfd,
8505 char *buf,
8506 int *bufsiz,
8507 const void *ppc_vmx,
8508 int size)
8509{
8510 char *note_name = "LINUX";
8511 return elfcore_write_note (abfd, buf, bufsiz,
8512 note_name, NT_PPC_VMX, ppc_vmx, size);
8513}
8514
89eeb0bc
LM		 8515char *
8516elfcore_write_ppc_vsx (bfd *abfd,
8517 char *buf,
8518 int *bufsiz,
8519 const void *ppc_vsx,
8520 int size)
8521{
8522 char *note_name = "LINUX";
8523 return elfcore_write_note (abfd, buf, bufsiz,
8524 note_name, NT_PPC_VSX, ppc_vsx, size);
8525}
8526
bb864ac1
CES		 8527char *
8528elfcore_write_register_note (bfd *abfd,
8529 char *buf,
8530 int *bufsiz,
8531 const char *section,
8532 const void *data,
8533 int size)
8534{
8535 if (strcmp (section, ".reg2") == 0)
8536 return elfcore_write_prfpreg (abfd, buf, bufsiz, data, size);
8537 if (strcmp (section, ".reg-xfp") == 0)
8538 return elfcore_write_prxfpreg (abfd, buf, bufsiz, data, size);
8539 if (strcmp (section, ".reg-ppc-vmx") == 0)
8540 return elfcore_write_ppc_vmx (abfd, buf, bufsiz, data, size);
89eeb0bc
LM		 8541 if (strcmp (section, ".reg-ppc-vsx") == 0)
8542 return elfcore_write_ppc_vsx (abfd, buf, bufsiz, data, size);
bb864ac1
CES		 8543 return NULL;
8544}
8545
b34976b6 8546static bfd_boolean
718175fa 8547elf_parse_notes (bfd *abfd, char *buf, size_t size, file_ptr offset)
252b5132 8548{
c044fabd 8549 char *p;
252b5132 8550
252b5132
RH		 8551 p = buf;
8552 while (p < buf + size)
8553 {
c044fabd
KH		 8554 /* FIXME: bad alignment assumption. */
8555 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH		 8556 Elf_Internal_Note in;
8557
baea7ef1
AM		 8558 if (offsetof (Elf_External_Note, name) > buf - p + size)
8559 return FALSE;
8560
dc810e39 8561 in.type = H_GET_32 (abfd, xnp->type);
252b5132 8562
dc810e39 8563 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132 8564 in.namedata = xnp->name;
baea7ef1
AM		 8565 if (in.namesz > buf - in.namedata + size)
8566 return FALSE;
252b5132 8567
dc810e39 8568 in.descsz = H_GET_32 (abfd, xnp->descsz);
252b5132
RH		 8569 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8570 in.descpos = offset + (in.descdata - buf);
baea7ef1
AM		 8571 if (in.descsz != 0
8572 && (in.descdata >= buf + size
8573 || in.descsz > buf - in.descdata + size))
8574 return FALSE;
252b5132 8575
718175fa
JK		 8576 switch (bfd_get_format (abfd))
8577 {
8578 default:
8579 return TRUE;
8580
8581 case bfd_core:
8582 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
8583 {
8584 if (! elfcore_grok_netbsd_note (abfd, &in))
8585 return FALSE;
8586 }
8587 else if (CONST_STRNEQ (in.namedata, "QNX"))
8588 {
8589 if (! elfcore_grok_nto_note (abfd, &in))
8590 return FALSE;
8591 }
b15fa79e
AM		 8592 else if (CONST_STRNEQ (in.namedata, "SPU/"))
8593 {
8594 if (! elfcore_grok_spu_note (abfd, &in))
8595 return FALSE;
8596 }
718175fa
JK		 8597 else
8598 {
8599 if (! elfcore_grok_note (abfd, &in))
8600 return FALSE;
8601 }
8602 break;
8603
8604 case bfd_object:
8605 if (in.namesz == sizeof "GNU" && strcmp (in.namedata, "GNU") == 0)
8606 {
8607 if (! elfobj_grok_gnu_note (abfd, &in))
8608 return FALSE;
8609 }
8610 break;
08a40648 8611 }
252b5132
RH		 8612
8613 p = in.descdata + BFD_ALIGN (in.descsz, 4);
8614 }
8615
718175fa
JK		 8616 return TRUE;
8617}
8618
8619static bfd_boolean
8620elf_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
8621{
8622 char *buf;
8623
8624 if (size <= 0)
8625 return TRUE;
8626
8627 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
8628 return FALSE;
8629
8630 buf = bfd_malloc (size);
8631 if (buf == NULL)
8632 return FALSE;
8633
8634 if (bfd_bread (buf, size, abfd) != size
8635 || !elf_parse_notes (abfd, buf, size, offset))
8636 {
8637 free (buf);
8638 return FALSE;
8639 }
8640
252b5132 8641 free (buf);
b34976b6 8642 return TRUE;
252b5132 8643}
98d8431c
JB		 8644\f
8645/* Providing external access to the ELF program header table. */
8646
8647/* Return an upper bound on the number of bytes required to store a
8648 copy of ABFD's program header table entries. Return -1 if an error
8649 occurs; bfd_get_error will return an appropriate code. */
c044fabd 8650
98d8431c 8651long
217aa764 8652bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB		 8653{
8654 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8655 {
8656 bfd_set_error (bfd_error_wrong_format);
8657 return -1;
8658 }
8659
936e320b 8660 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB		 8661}
8662
98d8431c
JB		 8663/* Copy ABFD's program header table entries to *PHDRS. The entries
8664 will be stored as an array of Elf_Internal_Phdr structures, as
8665 defined in include/elf/internal.h. To find out how large the
8666 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8667
8668 Return the number of program header table entries read, or -1 if an
8669 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 8670
98d8431c 8671int
217aa764 8672bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB		 8673{
8674 int num_phdrs;
8675
8676 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8677 {
8678 bfd_set_error (bfd_error_wrong_format);
8679 return -1;
8680 }
8681
8682 num_phdrs = elf_elfheader (abfd)->e_phnum;
c044fabd 8683 memcpy (phdrs, elf_tdata (abfd)->phdr,
98d8431c
JB		 8684 num_phdrs * sizeof (Elf_Internal_Phdr));
8685
8686 return num_phdrs;
8687}
ae4221d7 8688
db6751f2 8689enum elf_reloc_type_class
217aa764 8690_bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ		 8691{
8692 return reloc_class_normal;
8693}
f8df10f4 8694
47d9a591 8695/* For RELA architectures, return the relocation value for a
f8df10f4
JJ		 8696 relocation against a local symbol. */
8697
8698bfd_vma
217aa764
AM		 8699_bfd_elf_rela_local_sym (bfd *abfd,
8700 Elf_Internal_Sym *sym,
8517fae7 8701 asection **psec,
217aa764 8702 Elf_Internal_Rela *rel)
f8df10f4 8703{
8517fae7 8704 asection *sec = *psec;
f8df10f4
JJ		 8705 bfd_vma relocation;
8706
8707 relocation = (sec->output_section->vma
8708 + sec->output_offset
8709 + sym->st_value);
8710 if ((sec->flags & SEC_MERGE)
c629eae0 8711 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
68bfbfcc 8712 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
f8df10f4 8713 {
f8df10f4 8714 rel->r_addend =
8517fae7 8715 _bfd_merged_section_offset (abfd, psec,
65765700 8716 elf_section_data (sec)->sec_info,
753731ee
AM		 8717 sym->st_value + rel->r_addend);
8718 if (sec != *psec)
8719 {
8720 /* If we have changed the section, and our original section is
8721 marked with SEC_EXCLUDE, it means that the original
8722 SEC_MERGE section has been completely subsumed in some
8723 other SEC_MERGE section. In this case, we need to leave
8724 some info around for --emit-relocs. */
8725 if ((sec->flags & SEC_EXCLUDE) != 0)
8726 sec->kept_section = *psec;
8727 sec = *psec;
8728 }
8517fae7
AM		 8729 rel->r_addend -= relocation;
8730 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ		 8731 }
8732 return relocation;
8733}
c629eae0
JJ		 8734
8735bfd_vma
217aa764
AM		 8736_bfd_elf_rel_local_sym (bfd *abfd,
8737 Elf_Internal_Sym *sym,
8738 asection **psec,
8739 bfd_vma addend)
47d9a591 8740{
c629eae0
JJ		 8741 asection *sec = *psec;
8742
68bfbfcc 8743 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
c629eae0
JJ		 8744 return sym->st_value + addend;
8745
8746 return _bfd_merged_section_offset (abfd, psec,
65765700 8747 elf_section_data (sec)->sec_info,
753731ee 8748 sym->st_value + addend);
c629eae0
JJ		 8749}
8750
8751bfd_vma
217aa764 8752_bfd_elf_section_offset (bfd *abfd,
92e4ec35 8753 struct bfd_link_info *info,
217aa764
AM		 8754 asection *sec,
8755 bfd_vma offset)
c629eae0 8756{
68bfbfcc 8757 switch (sec->sec_info_type)
65765700
JJ		 8758 {
8759 case ELF_INFO_TYPE_STABS:
eea6121a
AM		 8760 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8761 offset);
65765700 8762 case ELF_INFO_TYPE_EH_FRAME:
92e4ec35 8763 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
65765700
JJ		 8764 default:
8765 return offset;
8766 }
c629eae0 8767}
3333a7c3
RM		 8768\f
8769/* Create a new BFD as if by bfd_openr. Rather than opening a file,
8770 reconstruct an ELF file by reading the segments out of remote memory
8771 based on the ELF file header at EHDR_VMA and the ELF program headers it
8772 points to. If not null, *LOADBASEP is filled in with the difference
8773 between the VMAs from which the segments were read, and the VMAs the
8774 file headers (and hence BFD's idea of each section's VMA) put them at.
8775
8776 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8777 remote memory at target address VMA into the local buffer at MYADDR; it
8778 should return zero on success or an `errno' code on failure. TEMPL must
8779 be a BFD for an ELF target with the word size and byte order found in
8780 the remote memory. */
8781
8782bfd *
217aa764
AM		 8783bfd_elf_bfd_from_remote_memory
8784 (bfd *templ,
8785 bfd_vma ehdr_vma,
8786 bfd_vma *loadbasep,
f075ee0c 8787 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
3333a7c3
RM		 8788{
8789 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8790 (templ, ehdr_vma, loadbasep, target_read_memory);
8791}
4c45e5c9
JJ		 8792\f
8793long
c9727e01
AM		 8794_bfd_elf_get_synthetic_symtab (bfd *abfd,
8795 long symcount ATTRIBUTE_UNUSED,
8796 asymbol **syms ATTRIBUTE_UNUSED,
8615f3f2 8797 long dynsymcount,
c9727e01
AM		 8798 asymbol **dynsyms,
8799 asymbol **ret)
4c45e5c9
JJ		 8800{
8801 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8802 asection *relplt;
8803 asymbol *s;
8804 const char *relplt_name;
8805 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8806 arelent *p;
8807 long count, i, n;
8808 size_t size;
8809 Elf_Internal_Shdr *hdr;
8810 char *names;
8811 asection *plt;
8812
8615f3f2
AM		 8813 *ret = NULL;
8814
90e3cdf2
JJ		 8815 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8816 return 0;
8817
8615f3f2
AM		 8818 if (dynsymcount <= 0)
8819 return 0;
8820
4c45e5c9
JJ		 8821 if (!bed->plt_sym_val)
8822 return 0;
8823
8824 relplt_name = bed->relplt_name;
8825 if (relplt_name == NULL)
d35fd659 8826 relplt_name = bed->rela_plts_and_copies_p ? ".rela.plt" : ".rel.plt";
4c45e5c9
JJ		 8827 relplt = bfd_get_section_by_name (abfd, relplt_name);
8828 if (relplt == NULL)
8829 return 0;
8830
8831 hdr = &elf_section_data (relplt)->this_hdr;
8832 if (hdr->sh_link != elf_dynsymtab (abfd)
8833 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8834 return 0;
8835
8836 plt = bfd_get_section_by_name (abfd, ".plt");
8837 if (plt == NULL)
8838 return 0;
8839
8840 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 8841 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ		 8842 return -1;
8843
eea6121a 8844 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ		 8845 size = count * sizeof (asymbol);
8846 p = relplt->relocation;
cb53bf42 8847 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
4c45e5c9
JJ		 8848 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8849
8850 s = *ret = bfd_malloc (size);
8851 if (s == NULL)
8852 return -1;
8853
8854 names = (char *) (s + count);
8855 p = relplt->relocation;
8856 n = 0;
cb53bf42 8857 for (i = 0; i < count; i++, p += bed->s->int_rels_per_ext_rel)
4c45e5c9
JJ		 8858 {
8859 size_t len;
8860 bfd_vma addr;
8861
8862 addr = bed->plt_sym_val (i, plt, p);
8863 if (addr == (bfd_vma) -1)
8864 continue;
8865
8866 *s = **p->sym_ptr_ptr;
65a7a66f
AM		 8867 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8868 we are defining a symbol, ensure one of them is set. */
8869 if ((s->flags & BSF_LOCAL) == 0)
8870 s->flags |= BSF_GLOBAL;
6ba2a415 8871 s->flags |= BSF_SYNTHETIC;
4c45e5c9
JJ		 8872 s->section = plt;
8873 s->value = addr - plt->vma;
8874 s->name = names;
8f39ba8e 8875 s->udata.p = NULL;
4c45e5c9
JJ		 8876 len = strlen ((*p->sym_ptr_ptr)->name);
8877 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8878 names += len;
8879 memcpy (names, "@plt", sizeof ("@plt"));
8880 names += sizeof ("@plt");
8f39ba8e 8881 ++s, ++n;
4c45e5c9
JJ		 8882 }
8883
8884 return n;
8885}
3d7f7666 8886
3b22753a
L		 8887/* It is only used by x86-64 so far. */
8888asection _bfd_elf_large_com_section
8889 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
f592407e 8890 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
ecca9871 8891
d1036acb
L		 8892void
8893_bfd_elf_set_osabi (bfd * abfd,
8894 struct bfd_link_info * link_info ATTRIBUTE_UNUSED)
8895{
8896 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
8897
8898 i_ehdrp = elf_elfheader (abfd);
8899
8900 i_ehdrp->e_ident[EI_OSABI] = get_elf_backend_data (abfd)->elf_osabi;
8901}
fcb93ecf
PB		 8902
8903
8904/* Return TRUE for ELF symbol types that represent functions.
8905 This is the default version of this function, which is sufficient for
0f88be7a 8906 most targets. It returns true if TYPE is STT_FUNC. */
fcb93ecf
PB		 8907
8908bfd_boolean
8909_bfd_elf_is_function_type (unsigned int type)
8910{
0f88be7a 8911 return (type == STT_FUNC);
fcb93ecf 8912}
GDB Binutils - Deliverables
This page took 1.375211 seconds and 4 git commands to generate.