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