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