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