projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
daily update
[deliverable/binutils-gdb.git] / bfd / elf.c
CommitLineData
252b5132 1/* ELF executable support for BFD.
340b6d91
AC		 2
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
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)
0ebdbb83
BW		 3874 {
3875 elf_tdata (abfd)->next_file_pos = bed->s->sizeof_ehdr;
3876 return TRUE;
3877 }
252b5132
RH		 3878
3879 /* If we already counted the number of program segments, make sure
3880 that we allocated enough space. This happens when SIZEOF_HEADERS
3881 is used in a linker script. */
3882 alloc = elf_tdata (abfd)->program_header_size / bed->s->sizeof_phdr;
3883 if (alloc != 0 && count > alloc)
3884 {
3885 ((*_bfd_error_handler)
b301b248
AM		 3886 (_("%B: Not enough room for program headers (allocated %u, need %u)"),
3887 abfd, alloc, count));
252b5132 3888 bfd_set_error (bfd_error_bad_value);
b34976b6 3889 return FALSE;
252b5132
RH		 3890 }
3891
3892 if (alloc == 0)
3893 alloc = count;
3894
dc810e39 3895 amt = alloc * sizeof (Elf_Internal_Phdr);
217aa764 3896 phdrs = bfd_alloc (abfd, amt);
252b5132 3897 if (phdrs == NULL)
b34976b6 3898 return FALSE;
252b5132
RH		 3899
3900 off = bed->s->sizeof_ehdr;
3901 off += alloc * bed->s->sizeof_phdr;
3902
3903 filehdr_vaddr = 0;
3904 filehdr_paddr = 0;
3905 phdrs_vaddr = 0;
3906 phdrs_paddr = 0;
3907
3908 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
3909 m != NULL;
3910 m = m->next, p++)
3911 {
3912 unsigned int i;
3913 asection **secpp;
3914
3915 /* If elf_segment_map is not from map_sections_to_segments, the
47d9a591 3916 sections may not be correctly ordered. NOTE: sorting should
52e9b619
MS		 3917 not be done to the PT_NOTE section of a corefile, which may
3918 contain several pseudo-sections artificially created by bfd.
3919 Sorting these pseudo-sections breaks things badly. */
47d9a591
AM		 3920 if (m->count > 1
3921 && !(elf_elfheader (abfd)->e_type == ET_CORE
52e9b619 3922 && m->p_type == PT_NOTE))
252b5132
RH		 3923 qsort (m->sections, (size_t) m->count, sizeof (asection *),
3924 elf_sort_sections);
3925
b301b248
AM		 3926 /* An ELF segment (described by Elf_Internal_Phdr) may contain a
3927 number of sections with contents contributing to both p_filesz
3928 and p_memsz, followed by a number of sections with no contents
3929 that just contribute to p_memsz. In this loop, OFF tracks next
3930 available file offset for PT_LOAD and PT_NOTE segments. VOFF is
3931 an adjustment we use for segments that have no file contents
3932 but need zero filled memory allocation. */
3933 voff = 0;
252b5132 3934 p->p_type = m->p_type;
28a7f3e7 3935 p->p_flags = m->p_flags;
252b5132
RH		 3936
3937 if (p->p_type == PT_LOAD
b301b248 3938 && m->count > 0)
252b5132 3939 {
b301b248
AM		 3940 bfd_size_type align;
3941 bfd_vma adjust;
3942
252b5132 3943 if ((abfd->flags & D_PAGED) != 0)
b301b248 3944 align = bed->maxpagesize;
252b5132
RH		 3945 else
3946 {
b301b248 3947 unsigned int align_power = 0;
252b5132
RH		 3948 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
3949 {
b301b248 3950 unsigned int secalign;
252b5132
RH		 3951
3952 secalign = bfd_get_section_alignment (abfd, *secpp);
b301b248
AM		 3953 if (secalign > align_power)
3954 align_power = secalign;
252b5132 3955 }
b301b248
AM		 3956 align = (bfd_size_type) 1 << align_power;
3957 }
252b5132 3958
b301b248
AM		 3959 adjust = vma_page_aligned_bias (m->sections[0]->vma, off, align);
3960 off += adjust;
3961 if (adjust != 0
3962 && !m->includes_filehdr
3963 && !m->includes_phdrs
3964 && (ufile_ptr) off >= align)
3965 {
3966 /* If the first section isn't loadable, the same holds for
3967 any other sections. Since the segment won't need file
3968 space, we can make p_offset overlap some prior segment.
3969 However, .tbss is special. If a segment starts with
3970 .tbss, we need to look at the next section to decide
3971 whether the segment has any loadable sections. */
3972 i = 0;
5efb6261 3973 while ((m->sections[i]->flags & SEC_LOAD) == 0)
b301b248
AM		 3974 {
3975 if ((m->sections[i]->flags & SEC_THREAD_LOCAL) == 0
3976 || ++i >= m->count)
3977 {
3978 off -= adjust;
3979 voff = adjust - align;
3980 break;
3981 }
3982 }
252b5132
RH		 3983 }
3984 }
b1a6d0b1
NC		 3985 /* Make sure the .dynamic section is the first section in the
3986 PT_DYNAMIC segment. */
3987 else if (p->p_type == PT_DYNAMIC
3988 && m->count > 1
3989 && strcmp (m->sections[0]->name, ".dynamic") != 0)
3990 {
3991 _bfd_error_handler
b301b248
AM		 3992 (_("%B: The first section in the PT_DYNAMIC segment is not the .dynamic section"),
3993 abfd);
b1a6d0b1
NC		 3994 bfd_set_error (bfd_error_bad_value);
3995 return FALSE;
3996 }
252b5132
RH		 3997
3998 if (m->count == 0)
3999 p->p_vaddr = 0;
4000 else
4001 p->p_vaddr = m->sections[0]->vma;
4002
4003 if (m->p_paddr_valid)
4004 p->p_paddr = m->p_paddr;
4005 else if (m->count == 0)
4006 p->p_paddr = 0;
4007 else
4008 p->p_paddr = m->sections[0]->lma;
4009
4010 if (p->p_type == PT_LOAD
4011 && (abfd->flags & D_PAGED) != 0)
4012 p->p_align = bed->maxpagesize;
4013 else if (m->count == 0)
45d6a902 4014 p->p_align = 1 << bed->s->log_file_align;
252b5132
RH		 4015 else
4016 p->p_align = 0;
4017
4018 p->p_offset = 0;
4019 p->p_filesz = 0;
4020 p->p_memsz = 0;
4021
4022 if (m->includes_filehdr)
4023 {
4024 if (! m->p_flags_valid)
4025 p->p_flags |= PF_R;
4026 p->p_offset = 0;
4027 p->p_filesz = bed->s->sizeof_ehdr;
4028 p->p_memsz = bed->s->sizeof_ehdr;
4029 if (m->count > 0)
4030 {
4031 BFD_ASSERT (p->p_type == PT_LOAD);
4032
4033 if (p->p_vaddr < (bfd_vma) off)
4034 {
caf47ea6 4035 (*_bfd_error_handler)
b301b248
AM		 4036 (_("%B: Not enough room for program headers, try linking with -N"),
4037 abfd);
252b5132 4038 bfd_set_error (bfd_error_bad_value);
b34976b6 4039 return FALSE;
252b5132
RH		 4040 }
4041
4042 p->p_vaddr -= off;
4043 if (! m->p_paddr_valid)
4044 p->p_paddr -= off;
4045 }
4046 if (p->p_type == PT_LOAD)
4047 {
4048 filehdr_vaddr = p->p_vaddr;
4049 filehdr_paddr = p->p_paddr;
4050 }
4051 }
4052
4053 if (m->includes_phdrs)
4054 {
4055 if (! m->p_flags_valid)
4056 p->p_flags |= PF_R;
4057
4058 if (m->includes_filehdr)
4059 {
4060 if (p->p_type == PT_LOAD)
4061 {
4062 phdrs_vaddr = p->p_vaddr + bed->s->sizeof_ehdr;
4063 phdrs_paddr = p->p_paddr + bed->s->sizeof_ehdr;
4064 }
4065 }
4066 else
4067 {
4068 p->p_offset = bed->s->sizeof_ehdr;
4069
4070 if (m->count > 0)
4071 {
4072 BFD_ASSERT (p->p_type == PT_LOAD);
4073 p->p_vaddr -= off - p->p_offset;
4074 if (! m->p_paddr_valid)
4075 p->p_paddr -= off - p->p_offset;
4076 }
4077
4078 if (p->p_type == PT_LOAD)
4079 {
4080 phdrs_vaddr = p->p_vaddr;
4081 phdrs_paddr = p->p_paddr;
4082 }
4083 else
4084 phdrs_vaddr = bed->maxpagesize + bed->s->sizeof_ehdr;
4085 }
4086
4087 p->p_filesz += alloc * bed->s->sizeof_phdr;
4088 p->p_memsz += alloc * bed->s->sizeof_phdr;
4089 }
4090
4091 if (p->p_type == PT_LOAD
4092 || (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core))
4093 {
4094 if (! m->includes_filehdr && ! m->includes_phdrs)
b301b248 4095 p->p_offset = off + voff;
252b5132
RH		 4096 else
4097 {
4098 file_ptr adjust;
4099
4100 adjust = off - (p->p_offset + p->p_filesz);
4101 p->p_filesz += adjust;
4102 p->p_memsz += adjust;
4103 }
4104 }
4105
252b5132
RH		 4106 for (i = 0, secpp = m->sections; i < m->count; i++, secpp++)
4107 {
4108 asection *sec;
4109 flagword flags;
4110 bfd_size_type align;
4111
4112 sec = *secpp;
4113 flags = sec->flags;
4114 align = 1 << bfd_get_section_alignment (abfd, sec);
4115
b301b248
AM		 4116 if (p->p_type == PT_LOAD
4117 || p->p_type == PT_TLS)
252b5132
RH		 4118 {
4119 bfd_signed_vma adjust;
4120
5efb6261 4121 if ((flags & SEC_LOAD) != 0)
252b5132 4122 {
b301b248 4123 adjust = sec->lma - (p->p_paddr + p->p_filesz);
252b5132 4124 if (adjust < 0)
b301b248
AM		 4125 {
4126 (*_bfd_error_handler)
4127 (_("%B: section %A lma 0x%lx overlaps previous sections"),
4128 abfd, sec, (unsigned long) sec->lma);
4129 adjust = 0;
4130 }
4131 off += adjust;
4132 p->p_filesz += adjust;
4133 p->p_memsz += adjust;
252b5132 4134 }
b301b248
AM		 4135 /* .tbss is special. It doesn't contribute to p_memsz of
4136 normal segments. */
4137 else if ((flags & SEC_THREAD_LOCAL) == 0
4138 || p->p_type == PT_TLS)
252b5132
RH		 4139 {
4140 /* The section VMA must equal the file position
b301b248
AM		 4141 modulo the page size. */
4142 bfd_size_type page = align;
252b5132 4143 if ((abfd->flags & D_PAGED) != 0)
b301b248
AM		 4144 page = bed->maxpagesize;
4145 adjust = vma_page_aligned_bias (sec->vma,
4146 p->p_vaddr + p->p_memsz,
4147 page);
252b5132 4148 p->p_memsz += adjust;
252b5132 4149 }
252b5132
RH		 4150 }
4151
4152 if (p->p_type == PT_NOTE && bfd_get_format (abfd) == bfd_core)
4153 {
b301b248
AM		 4154 /* The section at i == 0 is the one that actually contains
4155 everything. */
4a938328
MS		 4156 if (i == 0)
4157 {
252b5132 4158 sec->filepos = off;
eea6121a 4159 off += sec->size;
b301b248
AM		 4160 p->p_filesz = sec->size;
4161 p->p_memsz = 0;
4162 p->p_align = 1;
252b5132 4163 }
4a938328 4164 else
252b5132 4165 {
b301b248 4166 /* The rest are fake sections that shouldn't be written. */
252b5132 4167 sec->filepos = 0;
eea6121a 4168 sec->size = 0;
b301b248
AM		 4169 sec->flags = 0;
4170 continue;
252b5132 4171 }
252b5132
RH		 4172 }
4173 else
4174 {
b301b248
AM		 4175 if (p->p_type == PT_LOAD)
4176 {
4177 sec->filepos = off;
5efb6261
AM		 4178 /* FIXME: The SEC_HAS_CONTENTS test here dates back to
4179 1997, and the exact reason for it isn't clear. One
4180 plausible explanation is that it is to work around
4181 a problem we have with linker scripts using data
4182 statements in NOLOAD sections. I don't think it
4183 makes a great deal of sense to have such a section
4184 assigned to a PT_LOAD segment, but apparently
4185 people do this. The data statement results in a
4186 bfd_data_link_order being built, and these need
4187 section contents to write into. Eventually, we get
4188 to _bfd_elf_write_object_contents which writes any
4189 section with contents to the output. Make room
4190 here for the write, so that following segments are
4191 not trashed. */
4192 if ((flags & SEC_LOAD) != 0
4193 || (flags & SEC_HAS_CONTENTS) != 0)
b301b248
AM		 4194 off += sec->size;
4195 }
252b5132 4196
5efb6261 4197 if ((flags & SEC_LOAD) != 0)
b301b248
AM		 4198 {
4199 p->p_filesz += sec->size;
4200 p->p_memsz += sec->size;
4201 }
4202 /* .tbss is special. It doesn't contribute to p_memsz of
4203 normal segments. */
4204 else if ((flags & SEC_THREAD_LOCAL) == 0
4205 || p->p_type == PT_TLS)
4206 p->p_memsz += sec->size;
252b5132 4207
13ae64f3 4208 if (p->p_type == PT_TLS
eea6121a 4209 && sec->size == 0
13ae64f3
JJ		 4210 && (sec->flags & SEC_HAS_CONTENTS) == 0)
4211 {
4212 struct bfd_link_order *o;
4213 bfd_vma tbss_size = 0;
4214
4215 for (o = sec->link_order_head; o != NULL; o = o->next)
4216 if (tbss_size < o->offset + o->size)
4217 tbss_size = o->offset + o->size;
4218
4219 p->p_memsz += tbss_size;
4220 }
4221
252b5132
RH		 4222 if (align > p->p_align
4223 && (p->p_type != PT_LOAD || (abfd->flags & D_PAGED) == 0))
4224 p->p_align = align;
4225 }
4226
4227 if (! m->p_flags_valid)
4228 {
4229 p->p_flags |= PF_R;
4230 if ((flags & SEC_CODE) != 0)
4231 p->p_flags |= PF_X;
4232 if ((flags & SEC_READONLY) == 0)
4233 p->p_flags |= PF_W;
4234 }
4235 }
4236 }
4237
4238 /* Now that we have set the section file positions, we can set up
4239 the file positions for the non PT_LOAD segments. */
4240 for (m = elf_tdata (abfd)->segment_map, p = phdrs;
4241 m != NULL;
4242 m = m->next, p++)
4243 {
4244 if (p->p_type != PT_LOAD && m->count > 0)
4245 {
4246 BFD_ASSERT (! m->includes_filehdr && ! m->includes_phdrs);
229fcec5
MM		 4247 /* If the section has not yet been assigned a file position,
4248 do so now. The ARM BPABI requires that .dynamic section
4249 not be marked SEC_ALLOC because it is not part of any
4250 PT_LOAD segment, so it will not be processed above. */
4251 if (p->p_type == PT_DYNAMIC && m->sections[0]->filepos == 0)
4252 {
4253 unsigned int i;
4254 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
4255
4256 i = 1;
4257 while (i_shdrpp[i]->bfd_section != m->sections[0])
4258 ++i;
4259 off = (_bfd_elf_assign_file_position_for_section
4260 (i_shdrpp[i], off, TRUE));
4261 p->p_filesz = m->sections[0]->size;
4262 }
252b5132
RH		 4263 p->p_offset = m->sections[0]->filepos;
4264 }
4265 if (m->count == 0)
4266 {
4267 if (m->includes_filehdr)
4268 {
4269 p->p_vaddr = filehdr_vaddr;
4270 if (! m->p_paddr_valid)
4271 p->p_paddr = filehdr_paddr;
4272 }
4273 else if (m->includes_phdrs)
4274 {
4275 p->p_vaddr = phdrs_vaddr;
4276 if (! m->p_paddr_valid)
4277 p->p_paddr = phdrs_paddr;
4278 }
8c37241b
JJ		 4279 else if (p->p_type == PT_GNU_RELRO)
4280 {
4281 Elf_Internal_Phdr *lp;
4282
4283 for (lp = phdrs; lp < phdrs + count; ++lp)
4284 {
4285 if (lp->p_type == PT_LOAD
4286 && lp->p_vaddr <= link_info->relro_end
4287 && lp->p_vaddr >= link_info->relro_start
4288 && lp->p_vaddr + lp->p_filesz
4289 >= link_info->relro_end)
4290 break;
4291 }
4292
4293 if (lp < phdrs + count
4294 && link_info->relro_end > lp->p_vaddr)
4295 {
4296 p->p_vaddr = lp->p_vaddr;
4297 p->p_paddr = lp->p_paddr;
4298 p->p_offset = lp->p_offset;
4299 p->p_filesz = link_info->relro_end - lp->p_vaddr;
4300 p->p_memsz = p->p_filesz;
4301 p->p_align = 1;
4302 p->p_flags = (lp->p_flags & ~PF_W);
4303 }
4304 else
4305 {
4306 memset (p, 0, sizeof *p);
4307 p->p_type = PT_NULL;
4308 }
4309 }
252b5132
RH		 4310 }
4311 }
4312
4313 /* Clear out any program headers we allocated but did not use. */
4314 for (; count < alloc; count++, p++)
4315 {
4316 memset (p, 0, sizeof *p);
4317 p->p_type = PT_NULL;
4318 }
4319
4320 elf_tdata (abfd)->phdr = phdrs;
4321
4322 elf_tdata (abfd)->next_file_pos = off;
4323
4324 /* Write out the program headers. */
dc810e39 4325 if (bfd_seek (abfd, (bfd_signed_vma) bed->s->sizeof_ehdr, SEEK_SET) != 0
252b5132 4326 || bed->s->write_out_phdrs (abfd, phdrs, alloc) != 0)
b34976b6 4327 return FALSE;
252b5132 4328
b34976b6 4329 return TRUE;
252b5132
RH		 4330}
4331
4332/* Get the size of the program header.
4333
4334 If this is called by the linker before any of the section VMA's are set, it
4335 can't calculate the correct value for a strange memory layout. This only
4336 happens when SIZEOF_HEADERS is used in a linker script. In this case,
4337 SORTED_HDRS is NULL and we assume the normal scenario of one text and one
4338 data segment (exclusive of .interp and .dynamic).
4339
4340 ??? User written scripts must either not use SIZEOF_HEADERS, or assume there
4341 will be two segments. */
4342
4343static bfd_size_type
217aa764 4344get_program_header_size (bfd *abfd)
252b5132
RH		 4345{
4346 size_t segs;
4347 asection *s;
9c5bfbb7 4348 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4349
4350 /* We can't return a different result each time we're called. */
4351 if (elf_tdata (abfd)->program_header_size != 0)
4352 return elf_tdata (abfd)->program_header_size;
4353
4354 if (elf_tdata (abfd)->segment_map != NULL)
4355 {
4356 struct elf_segment_map *m;
4357
4358 segs = 0;
4359 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
4360 ++segs;
4361 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4362 return elf_tdata (abfd)->program_header_size;
4363 }
4364
4365 /* Assume we will need exactly two PT_LOAD segments: one for text
4366 and one for data. */
4367 segs = 2;
4368
4369 s = bfd_get_section_by_name (abfd, ".interp");
4370 if (s != NULL && (s->flags & SEC_LOAD) != 0)
4371 {
4372 /* If we have a loadable interpreter section, we need a
4373 PT_INTERP segment. In this case, assume we also need a
ab3acfbe 4374 PT_PHDR segment, although that may not be true for all
252b5132
RH		 4375 targets. */
4376 segs += 2;
4377 }
4378
4379 if (bfd_get_section_by_name (abfd, ".dynamic") != NULL)
4380 {
4381 /* We need a PT_DYNAMIC segment. */
4382 ++segs;
4383 }
4384
126495ed 4385 if (elf_tdata (abfd)->eh_frame_hdr)
65765700
JJ		 4386 {
4387 /* We need a PT_GNU_EH_FRAME segment. */
4388 ++segs;
4389 }
4390
9ee5e499
JJ		 4391 if (elf_tdata (abfd)->stack_flags)
4392 {
4393 /* We need a PT_GNU_STACK segment. */
4394 ++segs;
4395 }
4396
8c37241b
JJ		 4397 if (elf_tdata (abfd)->relro)
4398 {
4399 /* We need a PT_GNU_RELRO segment. */
4400 ++segs;
4401 }
4402
252b5132
RH		 4403 for (s = abfd->sections; s != NULL; s = s->next)
4404 {
4405 if ((s->flags & SEC_LOAD) != 0
4406 && strncmp (s->name, ".note", 5) == 0)
4407 {
4408 /* We need a PT_NOTE segment. */
4409 ++segs;
4410 }
4411 }
4412
13ae64f3
JJ		 4413 for (s = abfd->sections; s != NULL; s = s->next)
4414 {
4415 if (s->flags & SEC_THREAD_LOCAL)
4416 {
4417 /* We need a PT_TLS segment. */
4418 ++segs;
4419 break;
4420 }
4421 }
4422
252b5132
RH		 4423 /* Let the backend count up any program headers it might need. */
4424 if (bed->elf_backend_additional_program_headers)
4425 {
4426 int a;
4427
4428 a = (*bed->elf_backend_additional_program_headers) (abfd);
4429 if (a == -1)
4430 abort ();
4431 segs += a;
4432 }
4433
4434 elf_tdata (abfd)->program_header_size = segs * bed->s->sizeof_phdr;
4435 return elf_tdata (abfd)->program_header_size;
4436}
4437
4438/* Work out the file positions of all the sections. This is called by
4439 _bfd_elf_compute_section_file_positions. All the section sizes and
4440 VMAs must be known before this is called.
4441
e0638f70
AM		 4442 Reloc sections come in two flavours: Those processed specially as
4443 "side-channel" data attached to a section to which they apply, and
4444 those that bfd doesn't process as relocations. The latter sort are
4445 stored in a normal bfd section by bfd_section_from_shdr. We don't
4446 consider the former sort here, unless they form part of the loadable
4447 image. Reloc sections not assigned here will be handled later by
4448 assign_file_positions_for_relocs.
252b5132
RH		 4449
4450 We also don't set the positions of the .symtab and .strtab here. */
4451
b34976b6 4452static bfd_boolean
c84fca4d
AO		 4453assign_file_positions_except_relocs (bfd *abfd,
4454 struct bfd_link_info *link_info)
252b5132
RH		 4455{
4456 struct elf_obj_tdata * const tdata = elf_tdata (abfd);
4457 Elf_Internal_Ehdr * const i_ehdrp = elf_elfheader (abfd);
4458 Elf_Internal_Shdr ** const i_shdrpp = elf_elfsections (abfd);
9ad5cbcf 4459 unsigned int num_sec = elf_numsections (abfd);
252b5132 4460 file_ptr off;
9c5bfbb7 4461 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4462
4463 if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0
4464 && bfd_get_format (abfd) != bfd_core)
4465 {
4466 Elf_Internal_Shdr **hdrpp;
4467 unsigned int i;
4468
4469 /* Start after the ELF header. */
4470 off = i_ehdrp->e_ehsize;
4471
4472 /* We are not creating an executable, which means that we are
4473 not creating a program header, and that the actual order of
4474 the sections in the file is unimportant. */
9ad5cbcf 4475 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH		 4476 {
4477 Elf_Internal_Shdr *hdr;
4478
4479 hdr = *hdrpp;
e0638f70
AM		 4480 if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4481 && hdr->bfd_section == NULL)
9ad5cbcf
AM		 4482 || i == tdata->symtab_section
4483 || i == tdata->symtab_shndx_section
252b5132
RH		 4484 || i == tdata->strtab_section)
4485 {
4486 hdr->sh_offset = -1;
252b5132 4487 }
9ad5cbcf 4488 else
b34976b6 4489 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
252b5132 4490
9ad5cbcf
AM		 4491 if (i == SHN_LORESERVE - 1)
4492 {
4493 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4494 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4495 }
252b5132
RH		 4496 }
4497 }
4498 else
4499 {
4500 unsigned int i;
4501 Elf_Internal_Shdr **hdrpp;
4502
4503 /* Assign file positions for the loaded sections based on the
4504 assignment of sections to segments. */
c84fca4d 4505 if (! assign_file_positions_for_segments (abfd, link_info))
b34976b6 4506 return FALSE;
252b5132
RH		 4507
4508 /* Assign file positions for the other sections. */
4509
4510 off = elf_tdata (abfd)->next_file_pos;
9ad5cbcf 4511 for (i = 1, hdrpp = i_shdrpp + 1; i < num_sec; i++, hdrpp++)
252b5132
RH		 4512 {
4513 Elf_Internal_Shdr *hdr;
4514
4515 hdr = *hdrpp;
4516 if (hdr->bfd_section != NULL
4517 && hdr->bfd_section->filepos != 0)
4518 hdr->sh_offset = hdr->bfd_section->filepos;
4519 else if ((hdr->sh_flags & SHF_ALLOC) != 0)
4520 {
4521 ((*_bfd_error_handler)
b301b248
AM		 4522 (_("%B: warning: allocated section `%s' not in segment"),
4523 abfd,
252b5132
RH		 4524 (hdr->bfd_section == NULL
4525 ? "*unknown*"
4526 : hdr->bfd_section->name)));
4527 if ((abfd->flags & D_PAGED) != 0)
340b6d91
AC		 4528 off += vma_page_aligned_bias (hdr->sh_addr, off,
4529 bed->maxpagesize);
252b5132 4530 else
340b6d91
AC		 4531 off += vma_page_aligned_bias (hdr->sh_addr, off,
4532 hdr->sh_addralign);
252b5132 4533 off = _bfd_elf_assign_file_position_for_section (hdr, off,
b34976b6 4534 FALSE);
252b5132 4535 }
e0638f70
AM		 4536 else if (((hdr->sh_type == SHT_REL || hdr->sh_type == SHT_RELA)
4537 && hdr->bfd_section == NULL)
252b5132 4538 || hdr == i_shdrpp[tdata->symtab_section]
9ad5cbcf 4539 || hdr == i_shdrpp[tdata->symtab_shndx_section]
252b5132
RH		 4540 || hdr == i_shdrpp[tdata->strtab_section])
4541 hdr->sh_offset = -1;
4542 else
b34976b6 4543 off = _bfd_elf_assign_file_position_for_section (hdr, off, TRUE);
9ad5cbcf
AM		 4544
4545 if (i == SHN_LORESERVE - 1)
4546 {
4547 i += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4548 hdrpp += SHN_HIRESERVE + 1 - SHN_LORESERVE;
4549 }
252b5132
RH		 4550 }
4551 }
4552
4553 /* Place the section headers. */
45d6a902 4554 off = align_file_position (off, 1 << bed->s->log_file_align);
252b5132
RH		 4555 i_ehdrp->e_shoff = off;
4556 off += i_ehdrp->e_shnum * i_ehdrp->e_shentsize;
4557
4558 elf_tdata (abfd)->next_file_pos = off;
4559
b34976b6 4560 return TRUE;
252b5132
RH		 4561}
4562
b34976b6 4563static bfd_boolean
217aa764 4564prep_headers (bfd *abfd)
252b5132
RH		 4565{
4566 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
4567 Elf_Internal_Phdr *i_phdrp = 0; /* Program header table, internal form */
4568 Elf_Internal_Shdr **i_shdrp; /* Section header table, internal form */
2b0f7ef9 4569 struct elf_strtab_hash *shstrtab;
9c5bfbb7 4570 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4571
4572 i_ehdrp = elf_elfheader (abfd);
4573 i_shdrp = elf_elfsections (abfd);
4574
2b0f7ef9 4575 shstrtab = _bfd_elf_strtab_init ();
252b5132 4576 if (shstrtab == NULL)
b34976b6 4577 return FALSE;
252b5132
RH		 4578
4579 elf_shstrtab (abfd) = shstrtab;
4580
4581 i_ehdrp->e_ident[EI_MAG0] = ELFMAG0;
4582 i_ehdrp->e_ident[EI_MAG1] = ELFMAG1;
4583 i_ehdrp->e_ident[EI_MAG2] = ELFMAG2;
4584 i_ehdrp->e_ident[EI_MAG3] = ELFMAG3;
4585
4586 i_ehdrp->e_ident[EI_CLASS] = bed->s->elfclass;
4587 i_ehdrp->e_ident[EI_DATA] =
4588 bfd_big_endian (abfd) ? ELFDATA2MSB : ELFDATA2LSB;
4589 i_ehdrp->e_ident[EI_VERSION] = bed->s->ev_current;
4590
252b5132
RH		 4591 if ((abfd->flags & DYNAMIC) != 0)
4592 i_ehdrp->e_type = ET_DYN;
4593 else if ((abfd->flags & EXEC_P) != 0)
4594 i_ehdrp->e_type = ET_EXEC;
4595 else if (bfd_get_format (abfd) == bfd_core)
4596 i_ehdrp->e_type = ET_CORE;
4597 else
4598 i_ehdrp->e_type = ET_REL;
4599
4600 switch (bfd_get_arch (abfd))
4601 {
4602 case bfd_arch_unknown:
4603 i_ehdrp->e_machine = EM_NONE;
4604 break;
aa4f99bb
AO		 4605
4606 /* There used to be a long list of cases here, each one setting
4607 e_machine to the same EM_* macro #defined as ELF_MACHINE_CODE
4608 in the corresponding bfd definition. To avoid duplication,
4609 the switch was removed. Machines that need special handling
4610 can generally do it in elf_backend_final_write_processing(),
4611 unless they need the information earlier than the final write.
4612 Such need can generally be supplied by replacing the tests for
4613 e_machine with the conditions used to determine it. */
252b5132 4614 default:
9c5bfbb7
AM		 4615 i_ehdrp->e_machine = bed->elf_machine_code;
4616 }
aa4f99bb 4617
252b5132
RH		 4618 i_ehdrp->e_version = bed->s->ev_current;
4619 i_ehdrp->e_ehsize = bed->s->sizeof_ehdr;
4620
c044fabd 4621 /* No program header, for now. */
252b5132
RH		 4622 i_ehdrp->e_phoff = 0;
4623 i_ehdrp->e_phentsize = 0;
4624 i_ehdrp->e_phnum = 0;
4625
c044fabd 4626 /* Each bfd section is section header entry. */
252b5132
RH		 4627 i_ehdrp->e_entry = bfd_get_start_address (abfd);
4628 i_ehdrp->e_shentsize = bed->s->sizeof_shdr;
4629
c044fabd 4630 /* If we're building an executable, we'll need a program header table. */
252b5132
RH		 4631 if (abfd->flags & EXEC_P)
4632 {
c044fabd 4633 /* It all happens later. */
252b5132
RH		 4634#if 0
4635 i_ehdrp->e_phentsize = sizeof (Elf_External_Phdr);
4636
4637 /* elf_build_phdrs() returns a (NULL-terminated) array of
c044fabd 4638 Elf_Internal_Phdrs. */
252b5132
RH		 4639 i_phdrp = elf_build_phdrs (abfd, i_ehdrp, i_shdrp, &i_ehdrp->e_phnum);
4640 i_ehdrp->e_phoff = outbase;
4641 outbase += i_ehdrp->e_phentsize * i_ehdrp->e_phnum;
4642#endif
4643 }
4644 else
4645 {
4646 i_ehdrp->e_phentsize = 0;
4647 i_phdrp = 0;
4648 i_ehdrp->e_phoff = 0;
4649 }
4650
4651 elf_tdata (abfd)->symtab_hdr.sh_name =
b34976b6 4652 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".symtab", FALSE);
252b5132 4653 elf_tdata (abfd)->strtab_hdr.sh_name =
b34976b6 4654 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".strtab", FALSE);
252b5132 4655 elf_tdata (abfd)->shstrtab_hdr.sh_name =
b34976b6 4656 (unsigned int) _bfd_elf_strtab_add (shstrtab, ".shstrtab", FALSE);
252b5132
RH		 4657 if (elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4658 || elf_tdata (abfd)->symtab_hdr.sh_name == (unsigned int) -1
4659 || elf_tdata (abfd)->shstrtab_hdr.sh_name == (unsigned int) -1)
b34976b6 4660 return FALSE;
252b5132 4661
b34976b6 4662 return TRUE;
252b5132
RH		 4663}
4664
4665/* Assign file positions for all the reloc sections which are not part
4666 of the loadable file image. */
4667
4668void
217aa764 4669_bfd_elf_assign_file_positions_for_relocs (bfd *abfd)
252b5132
RH		 4670{
4671 file_ptr off;
9ad5cbcf 4672 unsigned int i, num_sec;
252b5132
RH		 4673 Elf_Internal_Shdr **shdrpp;
4674
4675 off = elf_tdata (abfd)->next_file_pos;
4676
9ad5cbcf
AM		 4677 num_sec = elf_numsections (abfd);
4678 for (i = 1, shdrpp = elf_elfsections (abfd) + 1; i < num_sec; i++, shdrpp++)
252b5132
RH		 4679 {
4680 Elf_Internal_Shdr *shdrp;
4681
4682 shdrp = *shdrpp;
4683 if ((shdrp->sh_type == SHT_REL || shdrp->sh_type == SHT_RELA)
4684 && shdrp->sh_offset == -1)
b34976b6 4685 off = _bfd_elf_assign_file_position_for_section (shdrp, off, TRUE);
252b5132
RH		 4686 }
4687
4688 elf_tdata (abfd)->next_file_pos = off;
4689}
4690
b34976b6 4691bfd_boolean
217aa764 4692_bfd_elf_write_object_contents (bfd *abfd)
252b5132 4693{
9c5bfbb7 4694 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132
RH		 4695 Elf_Internal_Ehdr *i_ehdrp;
4696 Elf_Internal_Shdr **i_shdrp;
b34976b6 4697 bfd_boolean failed;
9ad5cbcf 4698 unsigned int count, num_sec;
252b5132
RH		 4699
4700 if (! abfd->output_has_begun
217aa764 4701 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 4702 return FALSE;
252b5132
RH		 4703
4704 i_shdrp = elf_elfsections (abfd);
4705 i_ehdrp = elf_elfheader (abfd);
4706
b34976b6 4707 failed = FALSE;
252b5132
RH		 4708 bfd_map_over_sections (abfd, bed->s->write_relocs, &failed);
4709 if (failed)
b34976b6 4710 return FALSE;
252b5132
RH		 4711
4712 _bfd_elf_assign_file_positions_for_relocs (abfd);
4713
c044fabd 4714 /* After writing the headers, we need to write the sections too... */
9ad5cbcf
AM		 4715 num_sec = elf_numsections (abfd);
4716 for (count = 1; count < num_sec; count++)
252b5132
RH		 4717 {
4718 if (bed->elf_backend_section_processing)
4719 (*bed->elf_backend_section_processing) (abfd, i_shdrp[count]);
4720 if (i_shdrp[count]->contents)
4721 {
dc810e39
AM		 4722 bfd_size_type amt = i_shdrp[count]->sh_size;
4723
252b5132 4724 if (bfd_seek (abfd, i_shdrp[count]->sh_offset, SEEK_SET) != 0
dc810e39 4725 || bfd_bwrite (i_shdrp[count]->contents, amt, abfd) != amt)
b34976b6 4726 return FALSE;
252b5132 4727 }
9ad5cbcf
AM		 4728 if (count == SHN_LORESERVE - 1)
4729 count += SHN_HIRESERVE + 1 - SHN_LORESERVE;
252b5132
RH		 4730 }
4731
4732 /* Write out the section header names. */
4733 if (bfd_seek (abfd, elf_tdata (abfd)->shstrtab_hdr.sh_offset, SEEK_SET) != 0
2b0f7ef9 4734 || ! _bfd_elf_strtab_emit (abfd, elf_shstrtab (abfd)))
b34976b6 4735 return FALSE;
252b5132
RH		 4736
4737 if (bed->elf_backend_final_write_processing)
4738 (*bed->elf_backend_final_write_processing) (abfd,
4739 elf_tdata (abfd)->linker);
4740
4741 return bed->s->write_shdrs_and_ehdr (abfd);
4742}
4743
b34976b6 4744bfd_boolean
217aa764 4745_bfd_elf_write_corefile_contents (bfd *abfd)
252b5132 4746{
c044fabd 4747 /* Hopefully this can be done just like an object file. */
252b5132
RH		 4748 return _bfd_elf_write_object_contents (abfd);
4749}
c044fabd
KH		 4750
4751/* Given a section, search the header to find them. */
4752
252b5132 4753int
198beae2 4754_bfd_elf_section_from_bfd_section (bfd *abfd, struct bfd_section *asect)
252b5132 4755{
9c5bfbb7 4756 const struct elf_backend_data *bed;
252b5132 4757 int index;
252b5132 4758
9ad5cbcf
AM		 4759 if (elf_section_data (asect) != NULL
4760 && elf_section_data (asect)->this_idx != 0)
4761 return elf_section_data (asect)->this_idx;
4762
4763 if (bfd_is_abs_section (asect))
af746e92
AM		 4764 index = SHN_ABS;
4765 else if (bfd_is_com_section (asect))
4766 index = SHN_COMMON;
4767 else if (bfd_is_und_section (asect))
4768 index = SHN_UNDEF;
4769 else
252b5132 4770 {
af746e92
AM		 4771 Elf_Internal_Shdr **i_shdrp = elf_elfsections (abfd);
4772 int maxindex = elf_numsections (abfd);
4773
4774 for (index = 1; index < maxindex; index++)
4775 {
4776 Elf_Internal_Shdr *hdr = i_shdrp[index];
4777
4778 if (hdr != NULL && hdr->bfd_section == asect)
4779 return index;
4780 }
4781 index = -1;
252b5132
RH		 4782 }
4783
af746e92 4784 bed = get_elf_backend_data (abfd);
252b5132
RH		 4785 if (bed->elf_backend_section_from_bfd_section)
4786 {
af746e92 4787 int retval = index;
9ad5cbcf 4788
af746e92
AM		 4789 if ((*bed->elf_backend_section_from_bfd_section) (abfd, asect, &retval))
4790 return retval;
252b5132
RH		 4791 }
4792
af746e92
AM		 4793 if (index == -1)
4794 bfd_set_error (bfd_error_nonrepresentable_section);
252b5132 4795
af746e92 4796 return index;
252b5132
RH		 4797}
4798
4799/* Given a BFD symbol, return the index in the ELF symbol table, or -1
4800 on error. */
4801
4802int
217aa764 4803_bfd_elf_symbol_from_bfd_symbol (bfd *abfd, asymbol **asym_ptr_ptr)
252b5132
RH		 4804{
4805 asymbol *asym_ptr = *asym_ptr_ptr;
4806 int idx;
4807 flagword flags = asym_ptr->flags;
4808
4809 /* When gas creates relocations against local labels, it creates its
4810 own symbol for the section, but does put the symbol into the
4811 symbol chain, so udata is 0. When the linker is generating
4812 relocatable output, this section symbol may be for one of the
4813 input sections rather than the output section. */
4814 if (asym_ptr->udata.i == 0
4815 && (flags & BSF_SECTION_SYM)
4816 && asym_ptr->section)
4817 {
4818 int indx;
4819
4820 if (asym_ptr->section->output_section != NULL)
4821 indx = asym_ptr->section->output_section->index;
4822 else
4823 indx = asym_ptr->section->index;
4e89ac30
L		 4824 if (indx < elf_num_section_syms (abfd)
4825 && elf_section_syms (abfd)[indx] != NULL)
252b5132
RH		 4826 asym_ptr->udata.i = elf_section_syms (abfd)[indx]->udata.i;
4827 }
4828
4829 idx = asym_ptr->udata.i;
4830
4831 if (idx == 0)
4832 {
4833 /* This case can occur when using --strip-symbol on a symbol
4834 which is used in a relocation entry. */
4835 (*_bfd_error_handler)
d003868e
AM		 4836 (_("%B: symbol `%s' required but not present"),
4837 abfd, bfd_asymbol_name (asym_ptr));
252b5132
RH		 4838 bfd_set_error (bfd_error_no_symbols);
4839 return -1;
4840 }
4841
4842#if DEBUG & 4
4843 {
4844 fprintf (stderr,
661a3fd4 4845 "elf_symbol_from_bfd_symbol 0x%.8lx, name = %s, sym num = %d, flags = 0x%.8lx%s\n",
252b5132
RH		 4846 (long) asym_ptr, asym_ptr->name, idx, flags,
4847 elf_symbol_flags (flags));
4848 fflush (stderr);
4849 }
4850#endif
4851
4852 return idx;
4853}
4854
4855/* Copy private BFD data. This copies any program header information. */
4856
b34976b6 4857static bfd_boolean
217aa764 4858copy_private_bfd_data (bfd *ibfd, bfd *obfd)
252b5132 4859{
b34976b6
AM		 4860 Elf_Internal_Ehdr *iehdr;
4861 struct elf_segment_map *map;
4862 struct elf_segment_map *map_first;
4863 struct elf_segment_map **pointer_to_map;
4864 Elf_Internal_Phdr *segment;
4865 asection *section;
4866 unsigned int i;
4867 unsigned int num_segments;
4868 bfd_boolean phdr_included = FALSE;
4869 bfd_vma maxpagesize;
4870 struct elf_segment_map *phdr_adjust_seg = NULL;
4871 unsigned int phdr_adjust_num = 0;
9c5bfbb7 4872 const struct elf_backend_data *bed;
bc67d8a6 4873
c044fabd 4874 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
252b5132 4875 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 4876 return TRUE;
252b5132
RH		 4877
4878 if (elf_tdata (ibfd)->phdr == NULL)
b34976b6 4879 return TRUE;
252b5132 4880
caf47ea6 4881 bed = get_elf_backend_data (ibfd);
252b5132
RH		 4882 iehdr = elf_elfheader (ibfd);
4883
bc67d8a6 4884 map_first = NULL;
c044fabd 4885 pointer_to_map = &map_first;
252b5132
RH		 4886
4887 num_segments = elf_elfheader (ibfd)->e_phnum;
bc67d8a6
NC		 4888 maxpagesize = get_elf_backend_data (obfd)->maxpagesize;
4889
4890 /* Returns the end address of the segment + 1. */
aecc8f8a
AM		 4891#define SEGMENT_END(segment, start) \
4892 (start + (segment->p_memsz > segment->p_filesz \
4893 ? segment->p_memsz : segment->p_filesz))
bc67d8a6 4894
eecdbe52
JJ		 4895#define SECTION_SIZE(section, segment) \
4896 (((section->flags & (SEC_HAS_CONTENTS | SEC_THREAD_LOCAL)) \
4897 != SEC_THREAD_LOCAL || segment->p_type == PT_TLS) \
eea6121a 4898 ? section->size : 0)
eecdbe52 4899
b34976b6 4900 /* Returns TRUE if the given section is contained within
bc67d8a6 4901 the given segment. VMA addresses are compared. */
aecc8f8a
AM		 4902#define IS_CONTAINED_BY_VMA(section, segment) \
4903 (section->vma >= segment->p_vaddr \
eecdbe52 4904 && (section->vma + SECTION_SIZE (section, segment) \
aecc8f8a 4905 <= (SEGMENT_END (segment, segment->p_vaddr))))
c044fabd 4906
b34976b6 4907 /* Returns TRUE if the given section is contained within
bc67d8a6 4908 the given segment. LMA addresses are compared. */
aecc8f8a
AM		 4909#define IS_CONTAINED_BY_LMA(section, segment, base) \
4910 (section->lma >= base \
eecdbe52 4911 && (section->lma + SECTION_SIZE (section, segment) \
aecc8f8a 4912 <= SEGMENT_END (segment, base)))
252b5132 4913
c044fabd 4914 /* Special case: corefile "NOTE" section containing regs, prpsinfo etc. */
aecc8f8a
AM		 4915#define IS_COREFILE_NOTE(p, s) \
4916 (p->p_type == PT_NOTE \
4917 && bfd_get_format (ibfd) == bfd_core \
4918 && s->vma == 0 && s->lma == 0 \
4919 && (bfd_vma) s->filepos >= p->p_offset \
eea6121a 4920 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 4921 <= p->p_offset + p->p_filesz))
252b5132
RH		 4922
4923 /* The complicated case when p_vaddr is 0 is to handle the Solaris
4924 linker, which generates a PT_INTERP section with p_vaddr and
4925 p_memsz set to 0. */
aecc8f8a
AM		 4926#define IS_SOLARIS_PT_INTERP(p, s) \
4927 (p->p_vaddr == 0 \
4928 && p->p_paddr == 0 \
4929 && p->p_memsz == 0 \
4930 && p->p_filesz > 0 \
4931 && (s->flags & SEC_HAS_CONTENTS) != 0 \
eea6121a 4932 && s->size > 0 \
aecc8f8a 4933 && (bfd_vma) s->filepos >= p->p_offset \
eea6121a 4934 && ((bfd_vma) s->filepos + s->size \
aecc8f8a 4935 <= p->p_offset + p->p_filesz))
5c440b1e 4936
bc67d8a6
NC		 4937 /* Decide if the given section should be included in the given segment.
4938 A section will be included if:
f5ffc919
NC		 4939 1. It is within the address space of the segment -- we use the LMA
4940 if that is set for the segment and the VMA otherwise,
bc67d8a6
NC		 4941 2. It is an allocated segment,
4942 3. There is an output section associated with it,
eecdbe52 4943 4. The section has not already been allocated to a previous segment.
03394ac9
NC		 4944 5. PT_GNU_STACK segments do not include any sections.
4945 6. PT_TLS segment includes only SHF_TLS sections.
4946 7. SHF_TLS sections are only in PT_TLS or PT_LOAD segments. */
caf47ea6 4947#define INCLUDE_SECTION_IN_SEGMENT(section, segment, bed) \
aecc8f8a
AM		 4948 ((((segment->p_paddr \
4949 ? IS_CONTAINED_BY_LMA (section, segment, segment->p_paddr) \
4950 : IS_CONTAINED_BY_VMA (section, segment)) \
f5ffc919 4951 && (section->flags & SEC_ALLOC) != 0) \
b6821651 4952 || IS_COREFILE_NOTE (segment, section)) \
f5ffc919 4953 && section->output_section != NULL \
03394ac9 4954 && segment->p_type != PT_GNU_STACK \
eecdbe52
JJ		 4955 && (segment->p_type != PT_TLS \
4956 || (section->flags & SEC_THREAD_LOCAL)) \
4957 && (segment->p_type == PT_LOAD \
4958 || segment->p_type == PT_TLS \
4959 || (section->flags & SEC_THREAD_LOCAL) == 0) \
82e51918 4960 && ! section->segment_mark)
bc67d8a6 4961
b34976b6 4962 /* Returns TRUE iff seg1 starts after the end of seg2. */
b5f852ea
NC		 4963#define SEGMENT_AFTER_SEGMENT(seg1, seg2, field) \
4964 (seg1->field >= SEGMENT_END (seg2, seg2->field))
4965
4966 /* Returns TRUE iff seg1 and seg2 overlap. Segments overlap iff both
4967 their VMA address ranges and their LMA address ranges overlap.
4968 It is possible to have overlapping VMA ranges without overlapping LMA
4969 ranges. RedBoot images for example can have both .data and .bss mapped
4970 to the same VMA range, but with the .data section mapped to a different
4971 LMA. */
aecc8f8a 4972#define SEGMENT_OVERLAPS(seg1, seg2) \
b5f852ea
NC		 4973 ( !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_vaddr) \
4974 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_vaddr)) \
4975 && !(SEGMENT_AFTER_SEGMENT (seg1, seg2, p_paddr) \
4976 || SEGMENT_AFTER_SEGMENT (seg2, seg1, p_paddr)))
bc67d8a6
NC		 4977
4978 /* Initialise the segment mark field. */
4979 for (section = ibfd->sections; section != NULL; section = section->next)
b34976b6 4980 section->segment_mark = FALSE;
bc67d8a6 4981
252b5132 4982 /* Scan through the segments specified in the program header
bc67d8a6 4983 of the input BFD. For this first scan we look for overlaps
9ad5cbcf 4984 in the loadable segments. These can be created by weird
aecc8f8a 4985 parameters to objcopy. Also, fix some solaris weirdness. */
bc67d8a6
NC		 4986 for (i = 0, segment = elf_tdata (ibfd)->phdr;
4987 i < num_segments;
c044fabd 4988 i++, segment++)
252b5132 4989 {
252b5132 4990 unsigned int j;
c044fabd 4991 Elf_Internal_Phdr *segment2;
252b5132 4992
aecc8f8a
AM		 4993 if (segment->p_type == PT_INTERP)
4994 for (section = ibfd->sections; section; section = section->next)
4995 if (IS_SOLARIS_PT_INTERP (segment, section))
4996 {
4997 /* Mininal change so that the normal section to segment
4cc11e76 4998 assignment code will work. */
aecc8f8a
AM		 4999 segment->p_vaddr = section->vma;
5000 break;
5001 }
5002
bc67d8a6
NC		 5003 if (segment->p_type != PT_LOAD)
5004 continue;
c044fabd 5005
bc67d8a6 5006 /* Determine if this segment overlaps any previous segments. */
c044fabd 5007 for (j = 0, segment2 = elf_tdata (ibfd)->phdr; j < i; j++, segment2 ++)
bc67d8a6
NC		 5008 {
5009 bfd_signed_vma extra_length;
c044fabd 5010
bc67d8a6
NC		 5011 if (segment2->p_type != PT_LOAD
5012 || ! SEGMENT_OVERLAPS (segment, segment2))
5013 continue;
c044fabd 5014
bc67d8a6
NC		 5015 /* Merge the two segments together. */
5016 if (segment2->p_vaddr < segment->p_vaddr)
5017 {
c044fabd
KH		 5018 /* Extend SEGMENT2 to include SEGMENT and then delete
5019 SEGMENT. */
bc67d8a6
NC		 5020 extra_length =
5021 SEGMENT_END (segment, segment->p_vaddr)
5022 - SEGMENT_END (segment2, segment2->p_vaddr);
c044fabd 5023
bc67d8a6
NC		 5024 if (extra_length > 0)
5025 {
5026 segment2->p_memsz += extra_length;
5027 segment2->p_filesz += extra_length;
5028 }
c044fabd 5029
bc67d8a6 5030 segment->p_type = PT_NULL;
c044fabd 5031
bc67d8a6
NC		 5032 /* Since we have deleted P we must restart the outer loop. */
5033 i = 0;
5034 segment = elf_tdata (ibfd)->phdr;
5035 break;
5036 }
5037 else
5038 {
c044fabd
KH		 5039 /* Extend SEGMENT to include SEGMENT2 and then delete
5040 SEGMENT2. */
bc67d8a6
NC		 5041 extra_length =
5042 SEGMENT_END (segment2, segment2->p_vaddr)
5043 - SEGMENT_END (segment, segment->p_vaddr);
c044fabd 5044
bc67d8a6
NC		 5045 if (extra_length > 0)
5046 {
5047 segment->p_memsz += extra_length;
5048 segment->p_filesz += extra_length;
5049 }
c044fabd 5050
bc67d8a6
NC		 5051 segment2->p_type = PT_NULL;
5052 }
5053 }
5054 }
c044fabd 5055
bc67d8a6
NC		 5056 /* The second scan attempts to assign sections to segments. */
5057 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5058 i < num_segments;
5059 i ++, segment ++)
5060 {
5061 unsigned int section_count;
5062 asection ** sections;
5063 asection * output_section;
5064 unsigned int isec;
5065 bfd_vma matching_lma;
5066 bfd_vma suggested_lma;
5067 unsigned int j;
dc810e39 5068 bfd_size_type amt;
bc67d8a6
NC		 5069
5070 if (segment->p_type == PT_NULL)
5071 continue;
c044fabd 5072
bc67d8a6 5073 /* Compute how many sections might be placed into this segment. */
b5f852ea
NC		 5074 for (section = ibfd->sections, section_count = 0;
5075 section != NULL;
5076 section = section->next)
caf47ea6 5077 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c044fabd 5078 ++section_count;
811072d8 5079
b5f852ea
NC		 5080 /* Allocate a segment map big enough to contain
5081 all of the sections we have selected. */
dc810e39
AM		 5082 amt = sizeof (struct elf_segment_map);
5083 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
217aa764 5084 map = bfd_alloc (obfd, amt);
bc67d8a6 5085 if (map == NULL)
b34976b6 5086 return FALSE;
252b5132
RH		 5087
5088 /* Initialise the fields of the segment map. Default to
5089 using the physical address of the segment in the input BFD. */
bc67d8a6
NC		 5090 map->next = NULL;
5091 map->p_type = segment->p_type;
5092 map->p_flags = segment->p_flags;
5093 map->p_flags_valid = 1;
5094 map->p_paddr = segment->p_paddr;
5095 map->p_paddr_valid = 1;
252b5132
RH		 5096
5097 /* Determine if this segment contains the ELF file header
5098 and if it contains the program headers themselves. */
bc67d8a6
NC		 5099 map->includes_filehdr = (segment->p_offset == 0
5100 && segment->p_filesz >= iehdr->e_ehsize);
252b5132 5101
bc67d8a6 5102 map->includes_phdrs = 0;
252b5132 5103
bc67d8a6 5104 if (! phdr_included || segment->p_type != PT_LOAD)
252b5132 5105 {
bc67d8a6
NC		 5106 map->includes_phdrs =
5107 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5108 && (segment->p_offset + segment->p_filesz
252b5132
RH		 5109 >= ((bfd_vma) iehdr->e_phoff
5110 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 5111
bc67d8a6 5112 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 5113 phdr_included = TRUE;
252b5132
RH		 5114 }
5115
bc67d8a6 5116 if (section_count == 0)
252b5132
RH		 5117 {
5118 /* Special segments, such as the PT_PHDR segment, may contain
5119 no sections, but ordinary, loadable segments should contain
1ed89aa9
NC		 5120 something. They are allowed by the ELF spec however, so only
5121 a warning is produced. */
bc67d8a6 5122 if (segment->p_type == PT_LOAD)
caf47ea6 5123 (*_bfd_error_handler)
d003868e
AM		 5124 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5125 ibfd);
252b5132 5126
bc67d8a6 5127 map->count = 0;
c044fabd
KH		 5128 *pointer_to_map = map;
5129 pointer_to_map = &map->next;
252b5132
RH		 5130
5131 continue;
5132 }
5133
5134 /* Now scan the sections in the input BFD again and attempt
5135 to add their corresponding output sections to the segment map.
5136 The problem here is how to handle an output section which has
5137 been moved (ie had its LMA changed). There are four possibilities:
5138
5139 1. None of the sections have been moved.
5140 In this case we can continue to use the segment LMA from the
5141 input BFD.
5142
5143 2. All of the sections have been moved by the same amount.
5144 In this case we can change the segment's LMA to match the LMA
5145 of the first section.
5146
5147 3. Some of the sections have been moved, others have not.
5148 In this case those sections which have not been moved can be
5149 placed in the current segment which will have to have its size,
5150 and possibly its LMA changed, and a new segment or segments will
5151 have to be created to contain the other sections.
5152
b5f852ea 5153 4. The sections have been moved, but not by the same amount.
252b5132
RH		 5154 In this case we can change the segment's LMA to match the LMA
5155 of the first section and we will have to create a new segment
5156 or segments to contain the other sections.
5157
5158 In order to save time, we allocate an array to hold the section
5159 pointers that we are interested in. As these sections get assigned
5160 to a segment, they are removed from this array. */
5161
0b14c2aa
L		 5162 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5163 to work around this long long bug. */
5164 amt = section_count * sizeof (asection *);
217aa764 5165 sections = bfd_malloc (amt);
252b5132 5166 if (sections == NULL)
b34976b6 5167 return FALSE;
252b5132
RH		 5168
5169 /* Step One: Scan for segment vs section LMA conflicts.
5170 Also add the sections to the section array allocated above.
5171 Also add the sections to the current segment. In the common
5172 case, where the sections have not been moved, this means that
5173 we have completely filled the segment, and there is nothing
5174 more to do. */
252b5132 5175 isec = 0;
72730e0c 5176 matching_lma = 0;
252b5132
RH		 5177 suggested_lma = 0;
5178
bc67d8a6
NC		 5179 for (j = 0, section = ibfd->sections;
5180 section != NULL;
5181 section = section->next)
252b5132 5182 {
caf47ea6 5183 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 5184 {
bc67d8a6
NC		 5185 output_section = section->output_section;
5186
5187 sections[j ++] = section;
252b5132
RH		 5188
5189 /* The Solaris native linker always sets p_paddr to 0.
5190 We try to catch that case here, and set it to the
5e8d7549
NC		 5191 correct value. Note - some backends require that
5192 p_paddr be left as zero. */
bc67d8a6 5193 if (segment->p_paddr == 0
4455705d 5194 && segment->p_vaddr != 0
5e8d7549 5195 && (! bed->want_p_paddr_set_to_zero)
252b5132 5196 && isec == 0
bc67d8a6
NC		 5197 && output_section->lma != 0
5198 && (output_section->vma == (segment->p_vaddr
5199 + (map->includes_filehdr
5200 ? iehdr->e_ehsize
5201 : 0)
5202 + (map->includes_phdrs
079e9a2f
AM		 5203 ? (iehdr->e_phnum
5204 * iehdr->e_phentsize)
bc67d8a6
NC		 5205 : 0))))
5206 map->p_paddr = segment->p_vaddr;
252b5132
RH		 5207
5208 /* Match up the physical address of the segment with the
5209 LMA address of the output section. */
bc67d8a6 5210 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549
NC		 5211 || IS_COREFILE_NOTE (segment, section)
5212 || (bed->want_p_paddr_set_to_zero &&
5213 IS_CONTAINED_BY_VMA (output_section, segment))
5214 )
252b5132
RH		 5215 {
5216 if (matching_lma == 0)
bc67d8a6 5217 matching_lma = output_section->lma;
252b5132
RH		 5218
5219 /* We assume that if the section fits within the segment
bc67d8a6 5220 then it does not overlap any other section within that
252b5132 5221 segment. */
bc67d8a6 5222 map->sections[isec ++] = output_section;
252b5132
RH		 5223 }
5224 else if (suggested_lma == 0)
bc67d8a6 5225 suggested_lma = output_section->lma;
252b5132
RH		 5226 }
5227 }
5228
bc67d8a6 5229 BFD_ASSERT (j == section_count);
252b5132
RH		 5230
5231 /* Step Two: Adjust the physical address of the current segment,
5232 if necessary. */
bc67d8a6 5233 if (isec == section_count)
252b5132
RH		 5234 {
5235 /* All of the sections fitted within the segment as currently
5236 specified. This is the default case. Add the segment to
5237 the list of built segments and carry on to process the next
5238 program header in the input BFD. */
bc67d8a6 5239 map->count = section_count;
c044fabd
KH		 5240 *pointer_to_map = map;
5241 pointer_to_map = &map->next;
252b5132
RH		 5242
5243 free (sections);
5244 continue;
5245 }
252b5132
RH		 5246 else
5247 {
72730e0c
AM		 5248 if (matching_lma != 0)
5249 {
5250 /* At least one section fits inside the current segment.
5251 Keep it, but modify its physical address to match the
5252 LMA of the first section that fitted. */
bc67d8a6 5253 map->p_paddr = matching_lma;
72730e0c
AM		 5254 }
5255 else
5256 {
5257 /* None of the sections fitted inside the current segment.
5258 Change the current segment's physical address to match
5259 the LMA of the first section. */
bc67d8a6 5260 map->p_paddr = suggested_lma;
72730e0c
AM		 5261 }
5262
bc67d8a6
NC		 5263 /* Offset the segment physical address from the lma
5264 to allow for space taken up by elf headers. */
5265 if (map->includes_filehdr)
5266 map->p_paddr -= iehdr->e_ehsize;
252b5132 5267
bc67d8a6
NC		 5268 if (map->includes_phdrs)
5269 {
5270 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5271
5272 /* iehdr->e_phnum is just an estimate of the number
5273 of program headers that we will need. Make a note
5274 here of the number we used and the segment we chose
5275 to hold these headers, so that we can adjust the
5276 offset when we know the correct value. */
5277 phdr_adjust_num = iehdr->e_phnum;
5278 phdr_adjust_seg = map;
5279 }
252b5132
RH		 5280 }
5281
5282 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 5283 those that fit to the current segment and removing them from the
252b5132
RH		 5284 sections array; but making sure not to leave large gaps. Once all
5285 possible sections have been assigned to the current segment it is
5286 added to the list of built segments and if sections still remain
5287 to be assigned, a new segment is constructed before repeating
5288 the loop. */
5289 isec = 0;
5290 do
5291 {
bc67d8a6 5292 map->count = 0;
252b5132
RH		 5293 suggested_lma = 0;
5294
5295 /* Fill the current segment with sections that fit. */
bc67d8a6 5296 for (j = 0; j < section_count; j++)
252b5132 5297 {
bc67d8a6 5298 section = sections[j];
252b5132 5299
bc67d8a6 5300 if (section == NULL)
252b5132
RH		 5301 continue;
5302
bc67d8a6 5303 output_section = section->output_section;
252b5132 5304
bc67d8a6 5305 BFD_ASSERT (output_section != NULL);
c044fabd 5306
bc67d8a6
NC		 5307 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5308 || IS_COREFILE_NOTE (segment, section))
252b5132 5309 {
bc67d8a6 5310 if (map->count == 0)
252b5132
RH		 5311 {
5312 /* If the first section in a segment does not start at
bc67d8a6
NC		 5313 the beginning of the segment, then something is
5314 wrong. */
5315 if (output_section->lma !=
5316 (map->p_paddr
5317 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5318 + (map->includes_phdrs
5319 ? iehdr->e_phnum * iehdr->e_phentsize
5320 : 0)))
252b5132
RH		 5321 abort ();
5322 }
5323 else
5324 {
5325 asection * prev_sec;
252b5132 5326
bc67d8a6 5327 prev_sec = map->sections[map->count - 1];
252b5132
RH		 5328
5329 /* If the gap between the end of the previous section
bc67d8a6
NC		 5330 and the start of this section is more than
5331 maxpagesize then we need to start a new segment. */
eea6121a 5332 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 5333 maxpagesize)
caf47ea6 5334 < BFD_ALIGN (output_section->lma, maxpagesize))
eea6121a 5335 || ((prev_sec->lma + prev_sec->size)
079e9a2f 5336 > output_section->lma))
252b5132
RH		 5337 {
5338 if (suggested_lma == 0)
bc67d8a6 5339 suggested_lma = output_section->lma;
252b5132
RH		 5340
5341 continue;
5342 }
5343 }
5344
bc67d8a6 5345 map->sections[map->count++] = output_section;
252b5132
RH		 5346 ++isec;
5347 sections[j] = NULL;
b34976b6 5348 section->segment_mark = TRUE;
252b5132
RH		 5349 }
5350 else if (suggested_lma == 0)
bc67d8a6 5351 suggested_lma = output_section->lma;
252b5132
RH		 5352 }
5353
bc67d8a6 5354 BFD_ASSERT (map->count > 0);
252b5132
RH		 5355
5356 /* Add the current segment to the list of built segments. */
c044fabd
KH		 5357 *pointer_to_map = map;
5358 pointer_to_map = &map->next;
252b5132 5359
bc67d8a6 5360 if (isec < section_count)
252b5132
RH		 5361 {
5362 /* We still have not allocated all of the sections to
5363 segments. Create a new segment here, initialise it
5364 and carry on looping. */
dc810e39
AM		 5365 amt = sizeof (struct elf_segment_map);
5366 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
217aa764 5367 map = bfd_alloc (obfd, amt);
bc67d8a6 5368 if (map == NULL)
5ed6aba4
NC		 5369 {
5370 free (sections);
5371 return FALSE;
5372 }
252b5132
RH		 5373
5374 /* Initialise the fields of the segment map. Set the physical
5375 physical address to the LMA of the first section that has
5376 not yet been assigned. */
bc67d8a6
NC		 5377 map->next = NULL;
5378 map->p_type = segment->p_type;
5379 map->p_flags = segment->p_flags;
5380 map->p_flags_valid = 1;
5381 map->p_paddr = suggested_lma;
5382 map->p_paddr_valid = 1;
5383 map->includes_filehdr = 0;
5384 map->includes_phdrs = 0;
252b5132
RH		 5385 }
5386 }
bc67d8a6 5387 while (isec < section_count);
252b5132
RH		 5388
5389 free (sections);
5390 }
5391
5392 /* The Solaris linker creates program headers in which all the
5393 p_paddr fields are zero. When we try to objcopy or strip such a
5394 file, we get confused. Check for this case, and if we find it
5395 reset the p_paddr_valid fields. */
bc67d8a6
NC		 5396 for (map = map_first; map != NULL; map = map->next)
5397 if (map->p_paddr != 0)
252b5132 5398 break;
bc67d8a6 5399 if (map == NULL)
b5f852ea
NC		 5400 for (map = map_first; map != NULL; map = map->next)
5401 map->p_paddr_valid = 0;
252b5132 5402
bc67d8a6
NC		 5403 elf_tdata (obfd)->segment_map = map_first;
5404
5405 /* If we had to estimate the number of program headers that were
9ad5cbcf 5406 going to be needed, then check our estimate now and adjust
bc67d8a6
NC		 5407 the offset if necessary. */
5408 if (phdr_adjust_seg != NULL)
5409 {
5410 unsigned int count;
c044fabd 5411
bc67d8a6 5412 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 5413 count++;
252b5132 5414
bc67d8a6
NC		 5415 if (count > phdr_adjust_num)
5416 phdr_adjust_seg->p_paddr
5417 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5418 }
c044fabd 5419
252b5132 5420#if 0
c044fabd
KH		 5421 /* Final Step: Sort the segments into ascending order of physical
5422 address. */
bc67d8a6 5423 if (map_first != NULL)
252b5132 5424 {
c044fabd 5425 struct elf_segment_map *prev;
252b5132 5426
bc67d8a6
NC		 5427 prev = map_first;
5428 for (map = map_first->next; map != NULL; prev = map, map = map->next)
252b5132 5429 {
bc67d8a6
NC		 5430 /* Yes I know - its a bubble sort.... */
5431 if (map->next != NULL && (map->next->p_paddr < map->p_paddr))
252b5132 5432 {
bc67d8a6
NC		 5433 /* Swap map and map->next. */
5434 prev->next = map->next;
5435 map->next = map->next->next;
5436 prev->next->next = map;
252b5132 5437
bc67d8a6
NC		 5438 /* Restart loop. */
5439 map = map_first;
252b5132
RH		 5440 }
5441 }
5442 }
5443#endif
5444
bc67d8a6 5445#undef SEGMENT_END
eecdbe52 5446#undef SECTION_SIZE
bc67d8a6
NC		 5447#undef IS_CONTAINED_BY_VMA
5448#undef IS_CONTAINED_BY_LMA
252b5132 5449#undef IS_COREFILE_NOTE
bc67d8a6
NC		 5450#undef IS_SOLARIS_PT_INTERP
5451#undef INCLUDE_SECTION_IN_SEGMENT
5452#undef SEGMENT_AFTER_SEGMENT
5453#undef SEGMENT_OVERLAPS
b34976b6 5454 return TRUE;
252b5132
RH		 5455}
5456
5457/* Copy private section information. This copies over the entsize
5458 field, and sometimes the info field. */
5459
b34976b6 5460bfd_boolean
217aa764
AM		 5461_bfd_elf_copy_private_section_data (bfd *ibfd,
5462 asection *isec,
5463 bfd *obfd,
5464 asection *osec)
252b5132
RH		 5465{
5466 Elf_Internal_Shdr *ihdr, *ohdr;
5467
5468 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5469 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 5470 return TRUE;
252b5132 5471
252b5132
RH		 5472 ihdr = &elf_section_data (isec)->this_hdr;
5473 ohdr = &elf_section_data (osec)->this_hdr;
5474
5475 ohdr->sh_entsize = ihdr->sh_entsize;
5476
5477 if (ihdr->sh_type == SHT_SYMTAB
5478 || ihdr->sh_type == SHT_DYNSYM
5479 || ihdr->sh_type == SHT_GNU_verneed
5480 || ihdr->sh_type == SHT_GNU_verdef)
5481 ohdr->sh_info = ihdr->sh_info;
5482
9dce4196
AM		 5483 /* Set things up for objcopy. The output SHT_GROUP section will
5484 have its elf_next_in_group pointing back to the input group
5485 members. */
5486 elf_next_in_group (osec) = elf_next_in_group (isec);
5487 elf_group_name (osec) = elf_group_name (isec);
5488
68bfbfcc 5489 osec->use_rela_p = isec->use_rela_p;
bf572ba0 5490
b34976b6 5491 return TRUE;
252b5132
RH		 5492}
5493
80fccad2
BW		 5494/* Copy private header information. */
5495
5496bfd_boolean
5497_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
5498{
5499 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5500 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5501 return TRUE;
5502
5503 /* Copy over private BFD data if it has not already been copied.
5504 This must be done here, rather than in the copy_private_bfd_data
5505 entry point, because the latter is called after the section
5506 contents have been set, which means that the program headers have
5507 already been worked out. */
5508 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
5509 {
5510 if (! copy_private_bfd_data (ibfd, obfd))
5511 return FALSE;
5512 }
5513
5514 return TRUE;
5515}
5516
252b5132
RH		 5517/* Copy private symbol information. If this symbol is in a section
5518 which we did not map into a BFD section, try to map the section
5519 index correctly. We use special macro definitions for the mapped
5520 section indices; these definitions are interpreted by the
5521 swap_out_syms function. */
5522
9ad5cbcf
AM		 5523#define MAP_ONESYMTAB (SHN_HIOS + 1)
5524#define MAP_DYNSYMTAB (SHN_HIOS + 2)
5525#define MAP_STRTAB (SHN_HIOS + 3)
5526#define MAP_SHSTRTAB (SHN_HIOS + 4)
5527#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 5528
b34976b6 5529bfd_boolean
217aa764
AM		 5530_bfd_elf_copy_private_symbol_data (bfd *ibfd,
5531 asymbol *isymarg,
5532 bfd *obfd,
5533 asymbol *osymarg)
252b5132
RH		 5534{
5535 elf_symbol_type *isym, *osym;
5536
5537 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5538 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 5539 return TRUE;
252b5132
RH		 5540
5541 isym = elf_symbol_from (ibfd, isymarg);
5542 osym = elf_symbol_from (obfd, osymarg);
5543
5544 if (isym != NULL
5545 && osym != NULL
5546 && bfd_is_abs_section (isym->symbol.section))
5547 {
5548 unsigned int shndx;
5549
5550 shndx = isym->internal_elf_sym.st_shndx;
5551 if (shndx == elf_onesymtab (ibfd))
5552 shndx = MAP_ONESYMTAB;
5553 else if (shndx == elf_dynsymtab (ibfd))
5554 shndx = MAP_DYNSYMTAB;
5555 else if (shndx == elf_tdata (ibfd)->strtab_section)
5556 shndx = MAP_STRTAB;
5557 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
5558 shndx = MAP_SHSTRTAB;
9ad5cbcf
AM		 5559 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
5560 shndx = MAP_SYM_SHNDX;
252b5132
RH		 5561 osym->internal_elf_sym.st_shndx = shndx;
5562 }
5563
b34976b6 5564 return TRUE;
252b5132
RH		 5565}
5566
5567/* Swap out the symbols. */
5568
b34976b6 5569static bfd_boolean
217aa764
AM		 5570swap_out_syms (bfd *abfd,
5571 struct bfd_strtab_hash **sttp,
5572 int relocatable_p)
252b5132 5573{
9c5bfbb7 5574 const struct elf_backend_data *bed;
079e9a2f
AM		 5575 int symcount;
5576 asymbol **syms;
5577 struct bfd_strtab_hash *stt;
5578 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 5579 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f
AM		 5580 Elf_Internal_Shdr *symstrtab_hdr;
5581 char *outbound_syms;
9ad5cbcf 5582 char *outbound_shndx;
079e9a2f
AM		 5583 int idx;
5584 bfd_size_type amt;
174fd7f9 5585 bfd_boolean name_local_sections;
252b5132
RH		 5586
5587 if (!elf_map_symbols (abfd))
b34976b6 5588 return FALSE;
252b5132 5589
c044fabd 5590 /* Dump out the symtabs. */
079e9a2f
AM		 5591 stt = _bfd_elf_stringtab_init ();
5592 if (stt == NULL)
b34976b6 5593 return FALSE;
252b5132 5594
079e9a2f
AM		 5595 bed = get_elf_backend_data (abfd);
5596 symcount = bfd_get_symcount (abfd);
5597 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5598 symtab_hdr->sh_type = SHT_SYMTAB;
5599 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
5600 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
5601 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
45d6a902 5602 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
079e9a2f
AM		 5603
5604 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
5605 symstrtab_hdr->sh_type = SHT_STRTAB;
5606
5607 amt = (bfd_size_type) (1 + symcount) * bed->s->sizeof_sym;
5608 outbound_syms = bfd_alloc (abfd, amt);
5609 if (outbound_syms == NULL)
5ed6aba4
NC		 5610 {
5611 _bfd_stringtab_free (stt);
5612 return FALSE;
5613 }
217aa764 5614 symtab_hdr->contents = outbound_syms;
252b5132 5615
9ad5cbcf
AM		 5616 outbound_shndx = NULL;
5617 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
5618 if (symtab_shndx_hdr->sh_name != 0)
5619 {
5620 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
1126897b 5621 outbound_shndx = bfd_zalloc (abfd, amt);
9ad5cbcf 5622 if (outbound_shndx == NULL)
5ed6aba4
NC		 5623 {
5624 _bfd_stringtab_free (stt);
5625 return FALSE;
5626 }
5627
9ad5cbcf
AM		 5628 symtab_shndx_hdr->contents = outbound_shndx;
5629 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
5630 symtab_shndx_hdr->sh_size = amt;
5631 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
5632 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
5633 }
5634
589e6347 5635 /* Now generate the data (for "contents"). */
079e9a2f
AM		 5636 {
5637 /* Fill in zeroth symbol and swap it out. */
5638 Elf_Internal_Sym sym;
5639 sym.st_name = 0;
5640 sym.st_value = 0;
5641 sym.st_size = 0;
5642 sym.st_info = 0;
5643 sym.st_other = 0;
5644 sym.st_shndx = SHN_UNDEF;
9ad5cbcf 5645 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 5646 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 5647 if (outbound_shndx != NULL)
5648 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 5649 }
252b5132 5650
174fd7f9
RS		 5651 name_local_sections
5652 = (bed->elf_backend_name_local_section_symbols
5653 && bed->elf_backend_name_local_section_symbols (abfd));
5654
079e9a2f
AM		 5655 syms = bfd_get_outsymbols (abfd);
5656 for (idx = 0; idx < symcount; idx++)
252b5132 5657 {
252b5132 5658 Elf_Internal_Sym sym;
079e9a2f
AM		 5659 bfd_vma value = syms[idx]->value;
5660 elf_symbol_type *type_ptr;
5661 flagword flags = syms[idx]->flags;
5662 int type;
252b5132 5663
174fd7f9
RS		 5664 if (!name_local_sections
5665 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM		 5666 {
5667 /* Local section symbols have no name. */
5668 sym.st_name = 0;
5669 }
5670 else
5671 {
5672 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
5673 syms[idx]->name,
b34976b6 5674 TRUE, FALSE);
079e9a2f 5675 if (sym.st_name == (unsigned long) -1)
5ed6aba4
NC		 5676 {
5677 _bfd_stringtab_free (stt);
5678 return FALSE;
5679 }
079e9a2f 5680 }
252b5132 5681
079e9a2f 5682 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 5683
079e9a2f
AM		 5684 if ((flags & BSF_SECTION_SYM) == 0
5685 && bfd_is_com_section (syms[idx]->section))
5686 {
5687 /* ELF common symbols put the alignment into the `value' field,
5688 and the size into the `size' field. This is backwards from
5689 how BFD handles it, so reverse it here. */
5690 sym.st_size = value;
5691 if (type_ptr == NULL
5692 || type_ptr->internal_elf_sym.st_value == 0)
5693 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
5694 else
5695 sym.st_value = type_ptr->internal_elf_sym.st_value;
5696 sym.st_shndx = _bfd_elf_section_from_bfd_section
5697 (abfd, syms[idx]->section);
5698 }
5699 else
5700 {
5701 asection *sec = syms[idx]->section;
5702 int shndx;
252b5132 5703
079e9a2f
AM		 5704 if (sec->output_section)
5705 {
5706 value += sec->output_offset;
5707 sec = sec->output_section;
5708 }
589e6347 5709
079e9a2f
AM		 5710 /* Don't add in the section vma for relocatable output. */
5711 if (! relocatable_p)
5712 value += sec->vma;
5713 sym.st_value = value;
5714 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
5715
5716 if (bfd_is_abs_section (sec)
5717 && type_ptr != NULL
5718 && type_ptr->internal_elf_sym.st_shndx != 0)
5719 {
5720 /* This symbol is in a real ELF section which we did
5721 not create as a BFD section. Undo the mapping done
5722 by copy_private_symbol_data. */
5723 shndx = type_ptr->internal_elf_sym.st_shndx;
5724 switch (shndx)
5725 {
5726 case MAP_ONESYMTAB:
5727 shndx = elf_onesymtab (abfd);
5728 break;
5729 case MAP_DYNSYMTAB:
5730 shndx = elf_dynsymtab (abfd);
5731 break;
5732 case MAP_STRTAB:
5733 shndx = elf_tdata (abfd)->strtab_section;
5734 break;
5735 case MAP_SHSTRTAB:
5736 shndx = elf_tdata (abfd)->shstrtab_section;
5737 break;
9ad5cbcf
AM		 5738 case MAP_SYM_SHNDX:
5739 shndx = elf_tdata (abfd)->symtab_shndx_section;
5740 break;
079e9a2f
AM		 5741 default:
5742 break;
5743 }
5744 }
5745 else
5746 {
5747 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 5748
079e9a2f
AM		 5749 if (shndx == -1)
5750 {
5751 asection *sec2;
5752
5753 /* Writing this would be a hell of a lot easier if
5754 we had some decent documentation on bfd, and
5755 knew what to expect of the library, and what to
5756 demand of applications. For example, it
5757 appears that `objcopy' might not set the
5758 section of a symbol to be a section that is
5759 actually in the output file. */
5760 sec2 = bfd_get_section_by_name (abfd, sec->name);
589e6347
NC		 5761 if (sec2 == NULL)
5762 {
5763 _bfd_error_handler (_("\
5764Unable to find equivalent output section for symbol '%s' from section '%s'"),
5765 syms[idx]->name ? syms[idx]->name : "<Local sym>",
5766 sec->name);
811072d8 5767 bfd_set_error (bfd_error_invalid_operation);
5ed6aba4 5768 _bfd_stringtab_free (stt);
589e6347
NC		 5769 return FALSE;
5770 }
811072d8 5771
079e9a2f
AM		 5772 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
5773 BFD_ASSERT (shndx != -1);
5774 }
5775 }
252b5132 5776
079e9a2f
AM		 5777 sym.st_shndx = shndx;
5778 }
252b5132 5779
13ae64f3
JJ		 5780 if ((flags & BSF_THREAD_LOCAL) != 0)
5781 type = STT_TLS;
5782 else if ((flags & BSF_FUNCTION) != 0)
079e9a2f
AM		 5783 type = STT_FUNC;
5784 else if ((flags & BSF_OBJECT) != 0)
5785 type = STT_OBJECT;
5786 else
5787 type = STT_NOTYPE;
252b5132 5788
13ae64f3
JJ		 5789 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
5790 type = STT_TLS;
5791
589e6347 5792 /* Processor-specific types. */
079e9a2f
AM		 5793 if (type_ptr != NULL
5794 && bed->elf_backend_get_symbol_type)
5795 type = ((*bed->elf_backend_get_symbol_type)
5796 (&type_ptr->internal_elf_sym, type));
252b5132 5797
079e9a2f
AM		 5798 if (flags & BSF_SECTION_SYM)
5799 {
5800 if (flags & BSF_GLOBAL)
5801 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
5802 else
5803 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
5804 }
5805 else if (bfd_is_com_section (syms[idx]->section))
5806 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
5807 else if (bfd_is_und_section (syms[idx]->section))
5808 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
5809 ? STB_WEAK
5810 : STB_GLOBAL),
5811 type);
5812 else if (flags & BSF_FILE)
5813 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
5814 else
5815 {
5816 int bind = STB_LOCAL;
252b5132 5817
079e9a2f
AM		 5818 if (flags & BSF_LOCAL)
5819 bind = STB_LOCAL;
5820 else if (flags & BSF_WEAK)
5821 bind = STB_WEAK;
5822 else if (flags & BSF_GLOBAL)
5823 bind = STB_GLOBAL;
252b5132 5824
079e9a2f
AM		 5825 sym.st_info = ELF_ST_INFO (bind, type);
5826 }
252b5132 5827
079e9a2f
AM		 5828 if (type_ptr != NULL)
5829 sym.st_other = type_ptr->internal_elf_sym.st_other;
5830 else
5831 sym.st_other = 0;
252b5132 5832
9ad5cbcf 5833 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 5834 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 5835 if (outbound_shndx != NULL)
5836 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 5837 }
252b5132 5838
079e9a2f
AM		 5839 *sttp = stt;
5840 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
5841 symstrtab_hdr->sh_type = SHT_STRTAB;
252b5132 5842
079e9a2f
AM		 5843 symstrtab_hdr->sh_flags = 0;
5844 symstrtab_hdr->sh_addr = 0;
5845 symstrtab_hdr->sh_entsize = 0;
5846 symstrtab_hdr->sh_link = 0;
5847 symstrtab_hdr->sh_info = 0;
5848 symstrtab_hdr->sh_addralign = 1;
252b5132 5849
b34976b6 5850 return TRUE;
252b5132
RH		 5851}
5852
5853/* Return the number of bytes required to hold the symtab vector.
5854
5855 Note that we base it on the count plus 1, since we will null terminate
5856 the vector allocated based on this size. However, the ELF symbol table
5857 always has a dummy entry as symbol #0, so it ends up even. */
5858
5859long
217aa764 5860_bfd_elf_get_symtab_upper_bound (bfd *abfd)
252b5132
RH		 5861{
5862 long symcount;
5863 long symtab_size;
5864 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
5865
5866 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM		 5867 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5868 if (symcount > 0)
5869 symtab_size -= sizeof (asymbol *);
252b5132
RH		 5870
5871 return symtab_size;
5872}
5873
5874long
217aa764 5875_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
252b5132
RH		 5876{
5877 long symcount;
5878 long symtab_size;
5879 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
5880
5881 if (elf_dynsymtab (abfd) == 0)
5882 {
5883 bfd_set_error (bfd_error_invalid_operation);
5884 return -1;
5885 }
5886
5887 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM		 5888 symtab_size = (symcount + 1) * (sizeof (asymbol *));
5889 if (symcount > 0)
5890 symtab_size -= sizeof (asymbol *);
252b5132
RH		 5891
5892 return symtab_size;
5893}
5894
5895long
217aa764
AM		 5896_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
5897 sec_ptr asect)
252b5132
RH		 5898{
5899 return (asect->reloc_count + 1) * sizeof (arelent *);
5900}
5901
5902/* Canonicalize the relocs. */
5903
5904long
217aa764
AM		 5905_bfd_elf_canonicalize_reloc (bfd *abfd,
5906 sec_ptr section,
5907 arelent **relptr,
5908 asymbol **symbols)
252b5132
RH		 5909{
5910 arelent *tblptr;
5911 unsigned int i;
9c5bfbb7 5912 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 5913
b34976b6 5914 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
252b5132
RH		 5915 return -1;
5916
5917 tblptr = section->relocation;
5918 for (i = 0; i < section->reloc_count; i++)
5919 *relptr++ = tblptr++;
5920
5921 *relptr = NULL;
5922
5923 return section->reloc_count;
5924}
5925
5926long
6cee3f79 5927_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
252b5132 5928{
9c5bfbb7 5929 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 5930 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
252b5132
RH		 5931
5932 if (symcount >= 0)
5933 bfd_get_symcount (abfd) = symcount;
5934 return symcount;
5935}
5936
5937long
217aa764
AM		 5938_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
5939 asymbol **allocation)
252b5132 5940{
9c5bfbb7 5941 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 5942 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
1f70368c
DJ		 5943
5944 if (symcount >= 0)
5945 bfd_get_dynamic_symcount (abfd) = symcount;
5946 return symcount;
252b5132
RH		 5947}
5948
5949/* Return the size required for the dynamic reloc entries. Any
5950 section that was actually installed in the BFD, and has type
5951 SHT_REL or SHT_RELA, and uses the dynamic symbol table, is
5952 considered to be a dynamic reloc section. */
5953
5954long
217aa764 5955_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
252b5132
RH		 5956{
5957 long ret;
5958 asection *s;
5959
5960 if (elf_dynsymtab (abfd) == 0)
5961 {
5962 bfd_set_error (bfd_error_invalid_operation);
5963 return -1;
5964 }
5965
5966 ret = sizeof (arelent *);
5967 for (s = abfd->sections; s != NULL; s = s->next)
5968 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
5969 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
5970 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
eea6121a 5971 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
252b5132
RH		 5972 * sizeof (arelent *));
5973
5974 return ret;
5975}
5976
5977/* Canonicalize the dynamic relocation entries. Note that we return
5978 the dynamic relocations as a single block, although they are
5979 actually associated with particular sections; the interface, which
5980 was designed for SunOS style shared libraries, expects that there
5981 is only one set of dynamic relocs. Any section that was actually
5982 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses
5983 the dynamic symbol table, is considered to be a dynamic reloc
5984 section. */
5985
5986long
217aa764
AM		 5987_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
5988 arelent **storage,
5989 asymbol **syms)
252b5132 5990{
217aa764 5991 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
252b5132
RH		 5992 asection *s;
5993 long ret;
5994
5995 if (elf_dynsymtab (abfd) == 0)
5996 {
5997 bfd_set_error (bfd_error_invalid_operation);
5998 return -1;
5999 }
6000
6001 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6002 ret = 0;
6003 for (s = abfd->sections; s != NULL; s = s->next)
6004 {
6005 if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
6006 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6007 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6008 {
6009 arelent *p;
6010 long count, i;
6011
b34976b6 6012 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
252b5132 6013 return -1;
eea6121a 6014 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
252b5132
RH		 6015 p = s->relocation;
6016 for (i = 0; i < count; i++)
6017 *storage++ = p++;
6018 ret += count;
6019 }
6020 }
6021
6022 *storage = NULL;
6023
6024 return ret;
6025}
6026\f
6027/* Read in the version information. */
6028
b34976b6 6029bfd_boolean
217aa764 6030_bfd_elf_slurp_version_tables (bfd *abfd)
252b5132
RH		 6031{
6032 bfd_byte *contents = NULL;
dc810e39 6033 bfd_size_type amt;
252b5132
RH		 6034
6035 if (elf_dynverdef (abfd) != 0)
6036 {
6037 Elf_Internal_Shdr *hdr;
6038 Elf_External_Verdef *everdef;
6039 Elf_Internal_Verdef *iverdef;
f631889e
UD		 6040 Elf_Internal_Verdef *iverdefarr;
6041 Elf_Internal_Verdef iverdefmem;
252b5132 6042 unsigned int i;
062e2358 6043 unsigned int maxidx;
252b5132
RH		 6044
6045 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6046
217aa764 6047 contents = bfd_malloc (hdr->sh_size);
252b5132
RH		 6048 if (contents == NULL)
6049 goto error_return;
6050 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 6051 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
252b5132
RH		 6052 goto error_return;
6053
f631889e
UD		 6054 /* We know the number of entries in the section but not the maximum
6055 index. Therefore we have to run through all entries and find
6056 the maximum. */
252b5132 6057 everdef = (Elf_External_Verdef *) contents;
f631889e
UD		 6058 maxidx = 0;
6059 for (i = 0; i < hdr->sh_info; ++i)
6060 {
6061 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6062
062e2358
AM		 6063 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6064 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
f631889e
UD		 6065
6066 everdef = ((Elf_External_Verdef *)
6067 ((bfd_byte *) everdef + iverdefmem.vd_next));
6068 }
6069
dc810e39 6070 amt = (bfd_size_type) maxidx * sizeof (Elf_Internal_Verdef);
217aa764 6071 elf_tdata (abfd)->verdef = bfd_zalloc (abfd, amt);
f631889e
UD		 6072 if (elf_tdata (abfd)->verdef == NULL)
6073 goto error_return;
6074
6075 elf_tdata (abfd)->cverdefs = maxidx;
6076
6077 everdef = (Elf_External_Verdef *) contents;
6078 iverdefarr = elf_tdata (abfd)->verdef;
6079 for (i = 0; i < hdr->sh_info; i++)
252b5132
RH		 6080 {
6081 Elf_External_Verdaux *everdaux;
6082 Elf_Internal_Verdaux *iverdaux;
6083 unsigned int j;
6084
f631889e
UD		 6085 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6086
6087 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6088 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
252b5132
RH		 6089
6090 iverdef->vd_bfd = abfd;
6091
dc810e39 6092 amt = (bfd_size_type) iverdef->vd_cnt * sizeof (Elf_Internal_Verdaux);
217aa764 6093 iverdef->vd_auxptr = bfd_alloc (abfd, amt);
252b5132
RH		 6094 if (iverdef->vd_auxptr == NULL)
6095 goto error_return;
6096
6097 everdaux = ((Elf_External_Verdaux *)
6098 ((bfd_byte *) everdef + iverdef->vd_aux));
6099 iverdaux = iverdef->vd_auxptr;
6100 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6101 {
6102 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6103
6104 iverdaux->vda_nodename =
6105 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6106 iverdaux->vda_name);
6107 if (iverdaux->vda_nodename == NULL)
6108 goto error_return;
6109
6110 if (j + 1 < iverdef->vd_cnt)
6111 iverdaux->vda_nextptr = iverdaux + 1;
6112 else
6113 iverdaux->vda_nextptr = NULL;
6114
6115 everdaux = ((Elf_External_Verdaux *)
6116 ((bfd_byte *) everdaux + iverdaux->vda_next));
6117 }
6118
6119 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
6120
6121 if (i + 1 < hdr->sh_info)
6122 iverdef->vd_nextdef = iverdef + 1;
6123 else
6124 iverdef->vd_nextdef = NULL;
6125
6126 everdef = ((Elf_External_Verdef *)
6127 ((bfd_byte *) everdef + iverdef->vd_next));
6128 }
6129
6130 free (contents);
6131 contents = NULL;
6132 }
6133
6134 if (elf_dynverref (abfd) != 0)
6135 {
6136 Elf_Internal_Shdr *hdr;
6137 Elf_External_Verneed *everneed;
6138 Elf_Internal_Verneed *iverneed;
6139 unsigned int i;
6140
6141 hdr = &elf_tdata (abfd)->dynverref_hdr;
6142
dc810e39 6143 amt = (bfd_size_type) hdr->sh_info * sizeof (Elf_Internal_Verneed);
217aa764 6144 elf_tdata (abfd)->verref = bfd_zalloc (abfd, amt);
252b5132
RH		 6145 if (elf_tdata (abfd)->verref == NULL)
6146 goto error_return;
6147
6148 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6149
217aa764 6150 contents = bfd_malloc (hdr->sh_size);
252b5132
RH		 6151 if (contents == NULL)
6152 goto error_return;
6153 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 6154 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
252b5132
RH		 6155 goto error_return;
6156
6157 everneed = (Elf_External_Verneed *) contents;
6158 iverneed = elf_tdata (abfd)->verref;
6159 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6160 {
6161 Elf_External_Vernaux *evernaux;
6162 Elf_Internal_Vernaux *ivernaux;
6163 unsigned int j;
6164
6165 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6166
6167 iverneed->vn_bfd = abfd;
6168
6169 iverneed->vn_filename =
6170 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6171 iverneed->vn_file);
6172 if (iverneed->vn_filename == NULL)
6173 goto error_return;
6174
dc810e39
AM		 6175 amt = iverneed->vn_cnt;
6176 amt *= sizeof (Elf_Internal_Vernaux);
217aa764 6177 iverneed->vn_auxptr = bfd_alloc (abfd, amt);
252b5132
RH		 6178
6179 evernaux = ((Elf_External_Vernaux *)
6180 ((bfd_byte *) everneed + iverneed->vn_aux));
6181 ivernaux = iverneed->vn_auxptr;
6182 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6183 {
6184 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6185
6186 ivernaux->vna_nodename =
6187 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6188 ivernaux->vna_name);
6189 if (ivernaux->vna_nodename == NULL)
6190 goto error_return;
6191
6192 if (j + 1 < iverneed->vn_cnt)
6193 ivernaux->vna_nextptr = ivernaux + 1;
6194 else
6195 ivernaux->vna_nextptr = NULL;
6196
6197 evernaux = ((Elf_External_Vernaux *)
6198 ((bfd_byte *) evernaux + ivernaux->vna_next));
6199 }
6200
6201 if (i + 1 < hdr->sh_info)
6202 iverneed->vn_nextref = iverneed + 1;
6203 else
6204 iverneed->vn_nextref = NULL;
6205
6206 everneed = ((Elf_External_Verneed *)
6207 ((bfd_byte *) everneed + iverneed->vn_next));
6208 }
6209
6210 free (contents);
6211 contents = NULL;
6212 }
6213
b34976b6 6214 return TRUE;
252b5132
RH		 6215
6216 error_return:
5ed6aba4 6217 if (contents != NULL)
252b5132 6218 free (contents);
b34976b6 6219 return FALSE;
252b5132
RH		 6220}
6221\f
6222asymbol *
217aa764 6223_bfd_elf_make_empty_symbol (bfd *abfd)
252b5132
RH		 6224{
6225 elf_symbol_type *newsym;
dc810e39 6226 bfd_size_type amt = sizeof (elf_symbol_type);
252b5132 6227
217aa764 6228 newsym = bfd_zalloc (abfd, amt);
252b5132
RH		 6229 if (!newsym)
6230 return NULL;
6231 else
6232 {
6233 newsym->symbol.the_bfd = abfd;
6234 return &newsym->symbol;
6235 }
6236}
6237
6238void
217aa764
AM		 6239_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6240 asymbol *symbol,
6241 symbol_info *ret)
252b5132
RH		 6242{
6243 bfd_symbol_info (symbol, ret);
6244}
6245
6246/* Return whether a symbol name implies a local symbol. Most targets
6247 use this function for the is_local_label_name entry point, but some
6248 override it. */
6249
b34976b6 6250bfd_boolean
217aa764
AM		 6251_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6252 const char *name)
252b5132
RH		 6253{
6254 /* Normal local symbols start with ``.L''. */
6255 if (name[0] == '.' && name[1] == 'L')
b34976b6 6256 return TRUE;
252b5132
RH		 6257
6258 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6259 DWARF debugging symbols starting with ``..''. */
6260 if (name[0] == '.' && name[1] == '.')
b34976b6 6261 return TRUE;
252b5132
RH		 6262
6263 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6264 emitting DWARF debugging output. I suspect this is actually a
6265 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6266 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6267 underscore to be emitted on some ELF targets). For ease of use,
6268 we treat such symbols as local. */
6269 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
b34976b6 6270 return TRUE;
252b5132 6271
b34976b6 6272 return FALSE;
252b5132
RH		 6273}
6274
6275alent *
217aa764
AM		 6276_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6277 asymbol *symbol ATTRIBUTE_UNUSED)
252b5132
RH		 6278{
6279 abort ();
6280 return NULL;
6281}
6282
b34976b6 6283bfd_boolean
217aa764
AM		 6284_bfd_elf_set_arch_mach (bfd *abfd,
6285 enum bfd_architecture arch,
6286 unsigned long machine)
252b5132
RH		 6287{
6288 /* If this isn't the right architecture for this backend, and this
6289 isn't the generic backend, fail. */
6290 if (arch != get_elf_backend_data (abfd)->arch
6291 && arch != bfd_arch_unknown
6292 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
b34976b6 6293 return FALSE;
252b5132
RH		 6294
6295 return bfd_default_set_arch_mach (abfd, arch, machine);
6296}
6297
d1fad7c6
NC		 6298/* Find the function to a particular section and offset,
6299 for error reporting. */
252b5132 6300
b34976b6 6301static bfd_boolean
217aa764
AM		 6302elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
6303 asection *section,
6304 asymbol **symbols,
6305 bfd_vma offset,
6306 const char **filename_ptr,
6307 const char **functionname_ptr)
252b5132 6308{
252b5132
RH		 6309 const char *filename;
6310 asymbol *func;
6311 bfd_vma low_func;
6312 asymbol **p;
6313
252b5132
RH		 6314 filename = NULL;
6315 func = NULL;
6316 low_func = 0;
6317
6318 for (p = symbols; *p != NULL; p++)
6319 {
6320 elf_symbol_type *q;
6321
6322 q = (elf_symbol_type *) *p;
6323
252b5132
RH		 6324 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
6325 {
6326 default:
6327 break;
6328 case STT_FILE:
6329 filename = bfd_asymbol_name (&q->symbol);
6330 break;
6331 case STT_NOTYPE:
6332 case STT_FUNC:
6b40fcba 6333 if (bfd_get_section (&q->symbol) == section
252b5132
RH		 6334 && q->symbol.value >= low_func
6335 && q->symbol.value <= offset)
6336 {
6337 func = (asymbol *) q;
6338 low_func = q->symbol.value;
6339 }
6340 break;
6341 }
6342 }
6343
6344 if (func == NULL)
b34976b6 6345 return FALSE;
252b5132 6346
d1fad7c6
NC		 6347 if (filename_ptr)
6348 *filename_ptr = filename;
6349 if (functionname_ptr)
6350 *functionname_ptr = bfd_asymbol_name (func);
6351
b34976b6 6352 return TRUE;
d1fad7c6
NC		 6353}
6354
6355/* Find the nearest line to a particular section and offset,
6356 for error reporting. */
6357
b34976b6 6358bfd_boolean
217aa764
AM		 6359_bfd_elf_find_nearest_line (bfd *abfd,
6360 asection *section,
6361 asymbol **symbols,
6362 bfd_vma offset,
6363 const char **filename_ptr,
6364 const char **functionname_ptr,
6365 unsigned int *line_ptr)
d1fad7c6 6366{
b34976b6 6367 bfd_boolean found;
d1fad7c6
NC		 6368
6369 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 6370 filename_ptr, functionname_ptr,
6371 line_ptr))
d1fad7c6
NC		 6372 {
6373 if (!*functionname_ptr)
4e8a9624
AM		 6374 elf_find_function (abfd, section, symbols, offset,
6375 *filename_ptr ? NULL : filename_ptr,
6376 functionname_ptr);
6377
b34976b6 6378 return TRUE;
d1fad7c6
NC		 6379 }
6380
6381 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 6382 filename_ptr, functionname_ptr,
6383 line_ptr, 0,
6384 &elf_tdata (abfd)->dwarf2_find_line_info))
d1fad7c6
NC		 6385 {
6386 if (!*functionname_ptr)
4e8a9624
AM		 6387 elf_find_function (abfd, section, symbols, offset,
6388 *filename_ptr ? NULL : filename_ptr,
6389 functionname_ptr);
6390
b34976b6 6391 return TRUE;
d1fad7c6
NC		 6392 }
6393
6394 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM		 6395 &found, filename_ptr,
6396 functionname_ptr, line_ptr,
6397 &elf_tdata (abfd)->line_info))
b34976b6 6398 return FALSE;
dc43ada5 6399 if (found && (*functionname_ptr || *line_ptr))
b34976b6 6400 return TRUE;
d1fad7c6
NC		 6401
6402 if (symbols == NULL)
b34976b6 6403 return FALSE;
d1fad7c6
NC		 6404
6405 if (! elf_find_function (abfd, section, symbols, offset,
4e8a9624 6406 filename_ptr, functionname_ptr))
b34976b6 6407 return FALSE;
d1fad7c6 6408
252b5132 6409 *line_ptr = 0;
b34976b6 6410 return TRUE;
252b5132
RH		 6411}
6412
6413int
217aa764 6414_bfd_elf_sizeof_headers (bfd *abfd, bfd_boolean reloc)
252b5132
RH		 6415{
6416 int ret;
6417
6418 ret = get_elf_backend_data (abfd)->s->sizeof_ehdr;
6419 if (! reloc)
6420 ret += get_program_header_size (abfd);
6421 return ret;
6422}
6423
b34976b6 6424bfd_boolean
217aa764
AM		 6425_bfd_elf_set_section_contents (bfd *abfd,
6426 sec_ptr section,
0f867abe 6427 const void *location,
217aa764
AM		 6428 file_ptr offset,
6429 bfd_size_type count)
252b5132
RH		 6430{
6431 Elf_Internal_Shdr *hdr;
dc810e39 6432 bfd_signed_vma pos;
252b5132
RH		 6433
6434 if (! abfd->output_has_begun
217aa764 6435 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 6436 return FALSE;
252b5132
RH		 6437
6438 hdr = &elf_section_data (section)->this_hdr;
dc810e39
AM		 6439 pos = hdr->sh_offset + offset;
6440 if (bfd_seek (abfd, pos, SEEK_SET) != 0
6441 || bfd_bwrite (location, count, abfd) != count)
b34976b6 6442 return FALSE;
252b5132 6443
b34976b6 6444 return TRUE;
252b5132
RH		 6445}
6446
6447void
217aa764
AM		 6448_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
6449 arelent *cache_ptr ATTRIBUTE_UNUSED,
6450 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH		 6451{
6452 abort ();
6453}
6454
252b5132
RH		 6455/* Try to convert a non-ELF reloc into an ELF one. */
6456
b34976b6 6457bfd_boolean
217aa764 6458_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 6459{
c044fabd 6460 /* Check whether we really have an ELF howto. */
252b5132
RH		 6461
6462 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
6463 {
6464 bfd_reloc_code_real_type code;
6465 reloc_howto_type *howto;
6466
6467 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 6468 equivalent ELF reloc. */
252b5132
RH		 6469
6470 if (areloc->howto->pc_relative)
6471 {
6472 switch (areloc->howto->bitsize)
6473 {
6474 case 8:
6475 code = BFD_RELOC_8_PCREL;
6476 break;
6477 case 12:
6478 code = BFD_RELOC_12_PCREL;
6479 break;
6480 case 16:
6481 code = BFD_RELOC_16_PCREL;
6482 break;
6483 case 24:
6484 code = BFD_RELOC_24_PCREL;
6485 break;
6486 case 32:
6487 code = BFD_RELOC_32_PCREL;
6488 break;
6489 case 64:
6490 code = BFD_RELOC_64_PCREL;
6491 break;
6492 default:
6493 goto fail;
6494 }
6495
6496 howto = bfd_reloc_type_lookup (abfd, code);
6497
6498 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
6499 {
6500 if (howto->pcrel_offset)
6501 areloc->addend += areloc->address;
6502 else
6503 areloc->addend -= areloc->address; /* addend is unsigned!! */
6504 }
6505 }
6506 else
6507 {
6508 switch (areloc->howto->bitsize)
6509 {
6510 case 8:
6511 code = BFD_RELOC_8;
6512 break;
6513 case 14:
6514 code = BFD_RELOC_14;
6515 break;
6516 case 16:
6517 code = BFD_RELOC_16;
6518 break;
6519 case 26:
6520 code = BFD_RELOC_26;
6521 break;
6522 case 32:
6523 code = BFD_RELOC_32;
6524 break;
6525 case 64:
6526 code = BFD_RELOC_64;
6527 break;
6528 default:
6529 goto fail;
6530 }
6531
6532 howto = bfd_reloc_type_lookup (abfd, code);
6533 }
6534
6535 if (howto)
6536 areloc->howto = howto;
6537 else
6538 goto fail;
6539 }
6540
b34976b6 6541 return TRUE;
252b5132
RH		 6542
6543 fail:
6544 (*_bfd_error_handler)
d003868e
AM		 6545 (_("%B: unsupported relocation type %s"),
6546 abfd, areloc->howto->name);
252b5132 6547 bfd_set_error (bfd_error_bad_value);
b34976b6 6548 return FALSE;
252b5132
RH		 6549}
6550
b34976b6 6551bfd_boolean
217aa764 6552_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132
RH		 6553{
6554 if (bfd_get_format (abfd) == bfd_object)
6555 {
6556 if (elf_shstrtab (abfd) != NULL)
2b0f7ef9 6557 _bfd_elf_strtab_free (elf_shstrtab (abfd));
252b5132
RH		 6558 }
6559
6560 return _bfd_generic_close_and_cleanup (abfd);
6561}
6562
6563/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
6564 in the relocation's offset. Thus we cannot allow any sort of sanity
6565 range-checking to interfere. There is nothing else to do in processing
6566 this reloc. */
6567
6568bfd_reloc_status_type
217aa764
AM		 6569_bfd_elf_rel_vtable_reloc_fn
6570 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 6571 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM		 6572 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
6573 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH		 6574{
6575 return bfd_reloc_ok;
6576}
252b5132
RH		 6577\f
6578/* Elf core file support. Much of this only works on native
6579 toolchains, since we rely on knowing the
6580 machine-dependent procfs structure in order to pick
c044fabd 6581 out details about the corefile. */
252b5132
RH		 6582
6583#ifdef HAVE_SYS_PROCFS_H
6584# include <sys/procfs.h>
6585#endif
6586
c044fabd 6587/* FIXME: this is kinda wrong, but it's what gdb wants. */
252b5132
RH		 6588
6589static int
217aa764 6590elfcore_make_pid (bfd *abfd)
252b5132
RH		 6591{
6592 return ((elf_tdata (abfd)->core_lwpid << 16)
6593 + (elf_tdata (abfd)->core_pid));
6594}
6595
252b5132
RH		 6596/* If there isn't a section called NAME, make one, using
6597 data from SECT. Note, this function will generate a
6598 reference to NAME, so you shouldn't deallocate or
c044fabd 6599 overwrite it. */
252b5132 6600
b34976b6 6601static bfd_boolean
217aa764 6602elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 6603{
c044fabd 6604 asection *sect2;
252b5132
RH		 6605
6606 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 6607 return TRUE;
252b5132
RH		 6608
6609 sect2 = bfd_make_section (abfd, name);
6610 if (sect2 == NULL)
b34976b6 6611 return FALSE;
252b5132 6612
eea6121a 6613 sect2->size = sect->size;
252b5132
RH		 6614 sect2->filepos = sect->filepos;
6615 sect2->flags = sect->flags;
6616 sect2->alignment_power = sect->alignment_power;
b34976b6 6617 return TRUE;
252b5132
RH		 6618}
6619
bb0082d6
AM		 6620/* Create a pseudosection containing SIZE bytes at FILEPOS. This
6621 actually creates up to two pseudosections:
6622 - For the single-threaded case, a section named NAME, unless
6623 such a section already exists.
6624 - For the multi-threaded case, a section named "NAME/PID", where
6625 PID is elfcore_make_pid (abfd).
6626 Both pseudosections have identical contents. */
b34976b6 6627bfd_boolean
217aa764
AM		 6628_bfd_elfcore_make_pseudosection (bfd *abfd,
6629 char *name,
6630 size_t size,
6631 ufile_ptr filepos)
bb0082d6
AM		 6632{
6633 char buf[100];
6634 char *threaded_name;
d4c88bbb 6635 size_t len;
bb0082d6
AM		 6636 asection *sect;
6637
6638 /* Build the section name. */
6639
6640 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 6641 len = strlen (buf) + 1;
217aa764 6642 threaded_name = bfd_alloc (abfd, len);
bb0082d6 6643 if (threaded_name == NULL)
b34976b6 6644 return FALSE;
d4c88bbb 6645 memcpy (threaded_name, buf, len);
bb0082d6 6646
62f3bb11 6647 sect = bfd_make_section_anyway (abfd, threaded_name);
bb0082d6 6648 if (sect == NULL)
b34976b6 6649 return FALSE;
eea6121a 6650 sect->size = size;
bb0082d6
AM		 6651 sect->filepos = filepos;
6652 sect->flags = SEC_HAS_CONTENTS;
6653 sect->alignment_power = 2;
6654
936e320b 6655 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM		 6656}
6657
252b5132 6658/* prstatus_t exists on:
4a938328 6659 solaris 2.5+
252b5132
RH		 6660 linux 2.[01] + glibc
6661 unixware 4.2
6662*/
6663
6664#if defined (HAVE_PRSTATUS_T)
a7b97311 6665
b34976b6 6666static bfd_boolean
217aa764 6667elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 6668{
eea6121a 6669 size_t size;
7ee38065 6670 int offset;
252b5132 6671
4a938328
MS		 6672 if (note->descsz == sizeof (prstatus_t))
6673 {
6674 prstatus_t prstat;
252b5132 6675
eea6121a 6676 size = sizeof (prstat.pr_reg);
7ee38065 6677 offset = offsetof (prstatus_t, pr_reg);
4a938328 6678 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 6679
fa49d224
NC		 6680 /* Do not overwrite the core signal if it
6681 has already been set by another thread. */
6682 if (elf_tdata (abfd)->core_signal == 0)
6683 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4a938328 6684 elf_tdata (abfd)->core_pid = prstat.pr_pid;
252b5132 6685
4a938328
MS		 6686 /* pr_who exists on:
6687 solaris 2.5+
6688 unixware 4.2
6689 pr_who doesn't exist on:
6690 linux 2.[01]
6691 */
252b5132 6692#if defined (HAVE_PRSTATUS_T_PR_WHO)
4a938328 6693 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
252b5132 6694#endif
4a938328 6695 }
7ee38065 6696#if defined (HAVE_PRSTATUS32_T)
4a938328
MS		 6697 else if (note->descsz == sizeof (prstatus32_t))
6698 {
6699 /* 64-bit host, 32-bit corefile */
6700 prstatus32_t prstat;
6701
eea6121a 6702 size = sizeof (prstat.pr_reg);
7ee38065 6703 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS		 6704 memcpy (&prstat, note->descdata, sizeof (prstat));
6705
fa49d224
NC		 6706 /* Do not overwrite the core signal if it
6707 has already been set by another thread. */
6708 if (elf_tdata (abfd)->core_signal == 0)
6709 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4a938328
MS		 6710 elf_tdata (abfd)->core_pid = prstat.pr_pid;
6711
6712 /* pr_who exists on:
6713 solaris 2.5+
6714 unixware 4.2
6715 pr_who doesn't exist on:
6716 linux 2.[01]
6717 */
7ee38065 6718#if defined (HAVE_PRSTATUS32_T_PR_WHO)
4a938328
MS		 6719 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
6720#endif
6721 }
7ee38065 6722#endif /* HAVE_PRSTATUS32_T */
4a938328
MS		 6723 else
6724 {
6725 /* Fail - we don't know how to handle any other
6726 note size (ie. data object type). */
b34976b6 6727 return TRUE;
4a938328 6728 }
252b5132 6729
bb0082d6 6730 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 6731 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 6732 size, note->descpos + offset);
252b5132
RH		 6733}
6734#endif /* defined (HAVE_PRSTATUS_T) */
6735
bb0082d6 6736/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 6737static bfd_boolean
217aa764
AM		 6738elfcore_make_note_pseudosection (bfd *abfd,
6739 char *name,
6740 Elf_Internal_Note *note)
252b5132 6741{
936e320b
AM		 6742 return _bfd_elfcore_make_pseudosection (abfd, name,
6743 note->descsz, note->descpos);
252b5132
RH		 6744}
6745
ff08c6bb
JB		 6746/* There isn't a consistent prfpregset_t across platforms,
6747 but it doesn't matter, because we don't have to pick this
c044fabd
KH		 6748 data structure apart. */
6749
b34976b6 6750static bfd_boolean
217aa764 6751elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 6752{
6753 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
6754}
6755
ff08c6bb
JB		 6756/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
6757 type of 5 (NT_PRXFPREG). Just include the whole note's contents
6758 literally. */
c044fabd 6759
b34976b6 6760static bfd_boolean
217aa764 6761elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 6762{
6763 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
6764}
6765
252b5132 6766#if defined (HAVE_PRPSINFO_T)
4a938328 6767typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 6768#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 6769typedef prpsinfo32_t elfcore_psinfo32_t;
6770#endif
252b5132
RH		 6771#endif
6772
6773#if defined (HAVE_PSINFO_T)
4a938328 6774typedef psinfo_t elfcore_psinfo_t;
7ee38065 6775#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 6776typedef psinfo32_t elfcore_psinfo32_t;
6777#endif
252b5132
RH		 6778#endif
6779
252b5132
RH		 6780/* return a malloc'ed copy of a string at START which is at
6781 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 6782 the copy will always have a terminating '\0'. */
252b5132 6783
936e320b 6784char *
217aa764 6785_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 6786{
dc810e39 6787 char *dups;
c044fabd 6788 char *end = memchr (start, '\0', max);
dc810e39 6789 size_t len;
252b5132
RH		 6790
6791 if (end == NULL)
6792 len = max;
6793 else
6794 len = end - start;
6795
217aa764 6796 dups = bfd_alloc (abfd, len + 1);
dc810e39 6797 if (dups == NULL)
252b5132
RH		 6798 return NULL;
6799
dc810e39
AM		 6800 memcpy (dups, start, len);
6801 dups[len] = '\0';
252b5132 6802
dc810e39 6803 return dups;
252b5132
RH		 6804}
6805
bb0082d6 6806#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 6807static bfd_boolean
217aa764 6808elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 6809{
4a938328
MS		 6810 if (note->descsz == sizeof (elfcore_psinfo_t))
6811 {
6812 elfcore_psinfo_t psinfo;
252b5132 6813
7ee38065 6814 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 6815
4a938328 6816 elf_tdata (abfd)->core_program
936e320b
AM		 6817 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6818 sizeof (psinfo.pr_fname));
252b5132 6819
4a938328 6820 elf_tdata (abfd)->core_command
936e320b
AM		 6821 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6822 sizeof (psinfo.pr_psargs));
4a938328 6823 }
7ee38065 6824#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS		 6825 else if (note->descsz == sizeof (elfcore_psinfo32_t))
6826 {
6827 /* 64-bit host, 32-bit corefile */
6828 elfcore_psinfo32_t psinfo;
6829
7ee38065 6830 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 6831
4a938328 6832 elf_tdata (abfd)->core_program
936e320b
AM		 6833 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
6834 sizeof (psinfo.pr_fname));
4a938328
MS		 6835
6836 elf_tdata (abfd)->core_command
936e320b
AM		 6837 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
6838 sizeof (psinfo.pr_psargs));
4a938328
MS		 6839 }
6840#endif
6841
6842 else
6843 {
6844 /* Fail - we don't know how to handle any other
6845 note size (ie. data object type). */
b34976b6 6846 return TRUE;
4a938328 6847 }
252b5132
RH		 6848
6849 /* Note that for some reason, a spurious space is tacked
6850 onto the end of the args in some (at least one anyway)
c044fabd 6851 implementations, so strip it off if it exists. */
252b5132
RH		 6852
6853 {
c044fabd 6854 char *command = elf_tdata (abfd)->core_command;
252b5132
RH		 6855 int n = strlen (command);
6856
6857 if (0 < n && command[n - 1] == ' ')
6858 command[n - 1] = '\0';
6859 }
6860
b34976b6 6861 return TRUE;
252b5132
RH		 6862}
6863#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
6864
252b5132 6865#if defined (HAVE_PSTATUS_T)
b34976b6 6866static bfd_boolean
217aa764 6867elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 6868{
f572a39d
AM		 6869 if (note->descsz == sizeof (pstatus_t)
6870#if defined (HAVE_PXSTATUS_T)
6871 || note->descsz == sizeof (pxstatus_t)
6872#endif
6873 )
4a938328
MS		 6874 {
6875 pstatus_t pstat;
252b5132 6876
4a938328 6877 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 6878
4a938328
MS		 6879 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6880 }
7ee38065 6881#if defined (HAVE_PSTATUS32_T)
4a938328
MS		 6882 else if (note->descsz == sizeof (pstatus32_t))
6883 {
6884 /* 64-bit host, 32-bit corefile */
6885 pstatus32_t pstat;
252b5132 6886
4a938328 6887 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 6888
4a938328
MS		 6889 elf_tdata (abfd)->core_pid = pstat.pr_pid;
6890 }
6891#endif
252b5132
RH		 6892 /* Could grab some more details from the "representative"
6893 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 6894 NT_LWPSTATUS note, presumably. */
252b5132 6895
b34976b6 6896 return TRUE;
252b5132
RH		 6897}
6898#endif /* defined (HAVE_PSTATUS_T) */
6899
252b5132 6900#if defined (HAVE_LWPSTATUS_T)
b34976b6 6901static bfd_boolean
217aa764 6902elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH		 6903{
6904 lwpstatus_t lwpstat;
6905 char buf[100];
c044fabd 6906 char *name;
d4c88bbb 6907 size_t len;
c044fabd 6908 asection *sect;
252b5132 6909
f572a39d
AM		 6910 if (note->descsz != sizeof (lwpstat)
6911#if defined (HAVE_LWPXSTATUS_T)
6912 && note->descsz != sizeof (lwpxstatus_t)
6913#endif
6914 )
b34976b6 6915 return TRUE;
252b5132
RH		 6916
6917 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
6918
6919 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
6920 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
6921
c044fabd 6922 /* Make a ".reg/999" section. */
252b5132
RH		 6923
6924 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 6925 len = strlen (buf) + 1;
217aa764 6926 name = bfd_alloc (abfd, len);
252b5132 6927 if (name == NULL)
b34976b6 6928 return FALSE;
d4c88bbb 6929 memcpy (name, buf, len);
252b5132 6930
62f3bb11 6931 sect = bfd_make_section_anyway (abfd, name);
252b5132 6932 if (sect == NULL)
b34976b6 6933 return FALSE;
252b5132
RH		 6934
6935#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 6936 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH		 6937 sect->filepos = note->descpos
6938 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
6939#endif
6940
6941#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 6942 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH		 6943 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
6944#endif
6945
6946 sect->flags = SEC_HAS_CONTENTS;
6947 sect->alignment_power = 2;
6948
6949 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 6950 return FALSE;
252b5132
RH		 6951
6952 /* Make a ".reg2/999" section */
6953
6954 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 6955 len = strlen (buf) + 1;
217aa764 6956 name = bfd_alloc (abfd, len);
252b5132 6957 if (name == NULL)
b34976b6 6958 return FALSE;
d4c88bbb 6959 memcpy (name, buf, len);
252b5132 6960
62f3bb11 6961 sect = bfd_make_section_anyway (abfd, name);
252b5132 6962 if (sect == NULL)
b34976b6 6963 return FALSE;
252b5132
RH		 6964
6965#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 6966 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH		 6967 sect->filepos = note->descpos
6968 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
6969#endif
6970
6971#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 6972 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH		 6973 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
6974#endif
6975
6976 sect->flags = SEC_HAS_CONTENTS;
6977 sect->alignment_power = 2;
6978
936e320b 6979 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH		 6980}
6981#endif /* defined (HAVE_LWPSTATUS_T) */
6982
16e9c715 6983#if defined (HAVE_WIN32_PSTATUS_T)
b34976b6 6984static bfd_boolean
217aa764 6985elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC		 6986{
6987 char buf[30];
c044fabd 6988 char *name;
d4c88bbb 6989 size_t len;
c044fabd 6990 asection *sect;
16e9c715
NC		 6991 win32_pstatus_t pstatus;
6992
6993 if (note->descsz < sizeof (pstatus))
b34976b6 6994 return TRUE;
16e9c715 6995
e8eab623 6996 memcpy (&pstatus, note->descdata, sizeof (pstatus));
c044fabd
KH		 6997
6998 switch (pstatus.data_type)
16e9c715
NC		 6999 {
7000 case NOTE_INFO_PROCESS:
7001 /* FIXME: need to add ->core_command. */
7002 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7003 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
c044fabd 7004 break;
16e9c715
NC		 7005
7006 case NOTE_INFO_THREAD:
7007 /* Make a ".reg/999" section. */
7008 sprintf (buf, ".reg/%d", pstatus.data.thread_info.tid);
c044fabd 7009
d4c88bbb 7010 len = strlen (buf) + 1;
217aa764 7011 name = bfd_alloc (abfd, len);
16e9c715 7012 if (name == NULL)
b34976b6 7013 return FALSE;
c044fabd 7014
d4c88bbb 7015 memcpy (name, buf, len);
16e9c715 7016
62f3bb11 7017 sect = bfd_make_section_anyway (abfd, name);
16e9c715 7018 if (sect == NULL)
b34976b6 7019 return FALSE;
c044fabd 7020
eea6121a 7021 sect->size = sizeof (pstatus.data.thread_info.thread_context);
079e9a2f
AM		 7022 sect->filepos = (note->descpos
7023 + offsetof (struct win32_pstatus,
7024 data.thread_info.thread_context));
16e9c715
NC		 7025 sect->flags = SEC_HAS_CONTENTS;
7026 sect->alignment_power = 2;
7027
7028 if (pstatus.data.thread_info.is_active_thread)
7029 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 7030 return FALSE;
16e9c715
NC		 7031 break;
7032
7033 case NOTE_INFO_MODULE:
7034 /* Make a ".module/xxxxxxxx" section. */
c044fabd
KH		 7035 sprintf (buf, ".module/%08x", pstatus.data.module_info.base_address);
7036
d4c88bbb 7037 len = strlen (buf) + 1;
217aa764 7038 name = bfd_alloc (abfd, len);
16e9c715 7039 if (name == NULL)
b34976b6 7040 return FALSE;
c044fabd 7041
d4c88bbb 7042 memcpy (name, buf, len);
252b5132 7043
62f3bb11 7044 sect = bfd_make_section_anyway (abfd, name);
c044fabd 7045
16e9c715 7046 if (sect == NULL)
b34976b6 7047 return FALSE;
c044fabd 7048
eea6121a 7049 sect->size = note->descsz;
16e9c715
NC		 7050 sect->filepos = note->descpos;
7051 sect->flags = SEC_HAS_CONTENTS;
7052 sect->alignment_power = 2;
7053 break;
7054
7055 default:
b34976b6 7056 return TRUE;
16e9c715
NC		 7057 }
7058
b34976b6 7059 return TRUE;
16e9c715
NC		 7060}
7061#endif /* HAVE_WIN32_PSTATUS_T */
252b5132 7062
b34976b6 7063static bfd_boolean
217aa764 7064elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 7065{
9c5bfbb7 7066 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 7067
252b5132
RH		 7068 switch (note->type)
7069 {
7070 default:
b34976b6 7071 return TRUE;
252b5132 7072
252b5132 7073 case NT_PRSTATUS:
bb0082d6
AM		 7074 if (bed->elf_backend_grok_prstatus)
7075 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 7076 return TRUE;
bb0082d6 7077#if defined (HAVE_PRSTATUS_T)
252b5132 7078 return elfcore_grok_prstatus (abfd, note);
bb0082d6 7079#else
b34976b6 7080 return TRUE;
252b5132
RH		 7081#endif
7082
7083#if defined (HAVE_PSTATUS_T)
7084 case NT_PSTATUS:
7085 return elfcore_grok_pstatus (abfd, note);
7086#endif
7087
7088#if defined (HAVE_LWPSTATUS_T)
7089 case NT_LWPSTATUS:
7090 return elfcore_grok_lwpstatus (abfd, note);
7091#endif
7092
7093 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7094 return elfcore_grok_prfpreg (abfd, note);
7095
16e9c715 7096#if defined (HAVE_WIN32_PSTATUS_T)
c044fabd 7097 case NT_WIN32PSTATUS:
16e9c715
NC		 7098 return elfcore_grok_win32pstatus (abfd, note);
7099#endif
7100
c044fabd 7101 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK		 7102 if (note->namesz == 6
7103 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB		 7104 return elfcore_grok_prxfpreg (abfd, note);
7105 else
b34976b6 7106 return TRUE;
ff08c6bb 7107
252b5132
RH		 7108 case NT_PRPSINFO:
7109 case NT_PSINFO:
bb0082d6
AM		 7110 if (bed->elf_backend_grok_psinfo)
7111 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 7112 return TRUE;
bb0082d6 7113#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 7114 return elfcore_grok_psinfo (abfd, note);
bb0082d6 7115#else
b34976b6 7116 return TRUE;
252b5132 7117#endif
3333a7c3
RM		 7118
7119 case NT_AUXV:
7120 {
62f3bb11 7121 asection *sect = bfd_make_section_anyway (abfd, ".auxv");
3333a7c3
RM		 7122
7123 if (sect == NULL)
7124 return FALSE;
eea6121a 7125 sect->size = note->descsz;
3333a7c3
RM		 7126 sect->filepos = note->descpos;
7127 sect->flags = SEC_HAS_CONTENTS;
7128 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7129
7130 return TRUE;
7131 }
252b5132
RH		 7132 }
7133}
7134
b34976b6 7135static bfd_boolean
217aa764 7136elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM		 7137{
7138 char *cp;
7139
7140 cp = strchr (note->namedata, '@');
7141 if (cp != NULL)
7142 {
d2b64500 7143 *lwpidp = atoi(cp + 1);
b34976b6 7144 return TRUE;
50b2bdb7 7145 }
b34976b6 7146 return FALSE;
50b2bdb7
AM		 7147}
7148
b34976b6 7149static bfd_boolean
217aa764 7150elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 7151{
7152
7153 /* Signal number at offset 0x08. */
7154 elf_tdata (abfd)->core_signal
7155 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7156
7157 /* Process ID at offset 0x50. */
7158 elf_tdata (abfd)->core_pid
7159 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7160
7161 /* Command name at 0x7c (max 32 bytes, including nul). */
7162 elf_tdata (abfd)->core_command
7163 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7164
7720ba9f
MK		 7165 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7166 note);
50b2bdb7
AM		 7167}
7168
b34976b6 7169static bfd_boolean
217aa764 7170elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 7171{
7172 int lwp;
7173
7174 if (elfcore_netbsd_get_lwpid (note, &lwp))
7175 elf_tdata (abfd)->core_lwpid = lwp;
7176
b4db1224 7177 if (note->type == NT_NETBSDCORE_PROCINFO)
50b2bdb7
AM		 7178 {
7179 /* NetBSD-specific core "procinfo". Note that we expect to
7180 find this note before any of the others, which is fine,
7181 since the kernel writes this note out first when it
7182 creates a core file. */
47d9a591 7183
50b2bdb7
AM		 7184 return elfcore_grok_netbsd_procinfo (abfd, note);
7185 }
7186
b4db1224
JT		 7187 /* As of Jan 2002 there are no other machine-independent notes
7188 defined for NetBSD core files. If the note type is less
7189 than the start of the machine-dependent note types, we don't
7190 understand it. */
47d9a591 7191
b4db1224 7192 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 7193 return TRUE;
50b2bdb7
AM		 7194
7195
7196 switch (bfd_get_arch (abfd))
7197 {
7198 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7199 PT_GETFPREGS == mach+2. */
7200
7201 case bfd_arch_alpha:
7202 case bfd_arch_sparc:
7203 switch (note->type)
7204 {
b4db1224 7205 case NT_NETBSDCORE_FIRSTMACH+0:
50b2bdb7
AM		 7206 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7207
b4db1224 7208 case NT_NETBSDCORE_FIRSTMACH+2:
50b2bdb7
AM		 7209 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7210
7211 default:
b34976b6 7212 return TRUE;
50b2bdb7
AM		 7213 }
7214
7215 /* On all other arch's, PT_GETREGS == mach+1 and
7216 PT_GETFPREGS == mach+3. */
7217
7218 default:
7219 switch (note->type)
7220 {
b4db1224 7221 case NT_NETBSDCORE_FIRSTMACH+1:
50b2bdb7
AM		 7222 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7223
b4db1224 7224 case NT_NETBSDCORE_FIRSTMACH+3:
50b2bdb7
AM		 7225 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7226
7227 default:
b34976b6 7228 return TRUE;
50b2bdb7
AM		 7229 }
7230 }
7231 /* NOTREACHED */
7232}
7233
07c6e936 7234static bfd_boolean
217aa764 7235elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, pid_t *tid)
07c6e936
NC		 7236{
7237 void *ddata = note->descdata;
7238 char buf[100];
7239 char *name;
7240 asection *sect;
f8843e87
AM		 7241 short sig;
7242 unsigned flags;
07c6e936
NC		 7243
7244 /* nto_procfs_status 'pid' field is at offset 0. */
7245 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
7246
f8843e87
AM		 7247 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
7248 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
7249
7250 /* nto_procfs_status 'flags' field is at offset 8. */
7251 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC		 7252
7253 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM		 7254 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
7255 {
7256 elf_tdata (abfd)->core_signal = sig;
7257 elf_tdata (abfd)->core_lwpid = *tid;
7258 }
07c6e936 7259
f8843e87
AM		 7260 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
7261 do not come from signals so we make sure we set the current
7262 thread just in case. */
7263 if (flags & 0x00000080)
7264 elf_tdata (abfd)->core_lwpid = *tid;
07c6e936
NC		 7265
7266 /* Make a ".qnx_core_status/%d" section. */
7267 sprintf (buf, ".qnx_core_status/%d", *tid);
7268
217aa764 7269 name = bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 7270 if (name == NULL)
7271 return FALSE;
7272 strcpy (name, buf);
7273
62f3bb11 7274 sect = bfd_make_section_anyway (abfd, name);
07c6e936
NC		 7275 if (sect == NULL)
7276 return FALSE;
7277
eea6121a 7278 sect->size = note->descsz;
07c6e936
NC		 7279 sect->filepos = note->descpos;
7280 sect->flags = SEC_HAS_CONTENTS;
7281 sect->alignment_power = 2;
7282
7283 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
7284}
7285
7286static bfd_boolean
217aa764 7287elfcore_grok_nto_gregs (bfd *abfd, Elf_Internal_Note *note, pid_t tid)
07c6e936
NC		 7288{
7289 char buf[100];
7290 char *name;
7291 asection *sect;
7292
7293 /* Make a ".reg/%d" section. */
7294 sprintf (buf, ".reg/%d", tid);
7295
217aa764 7296 name = bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 7297 if (name == NULL)
7298 return FALSE;
7299 strcpy (name, buf);
7300
62f3bb11 7301 sect = bfd_make_section_anyway (abfd, name);
07c6e936
NC		 7302 if (sect == NULL)
7303 return FALSE;
7304
eea6121a 7305 sect->size = note->descsz;
07c6e936
NC		 7306 sect->filepos = note->descpos;
7307 sect->flags = SEC_HAS_CONTENTS;
7308 sect->alignment_power = 2;
7309
f8843e87
AM		 7310 /* This is the current thread. */
7311 if (elf_tdata (abfd)->core_lwpid == tid)
7312 return elfcore_maybe_make_sect (abfd, ".reg", sect);
7313
7314 return TRUE;
07c6e936
NC		 7315}
7316
7317#define BFD_QNT_CORE_INFO 7
7318#define BFD_QNT_CORE_STATUS 8
7319#define BFD_QNT_CORE_GREG 9
7320#define BFD_QNT_CORE_FPREG 10
7321
7322static bfd_boolean
217aa764 7323elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC		 7324{
7325 /* Every GREG section has a STATUS section before it. Store the
811072d8 7326 tid from the previous call to pass down to the next gregs
07c6e936
NC		 7327 function. */
7328 static pid_t tid = 1;
7329
7330 switch (note->type)
7331 {
7332 case BFD_QNT_CORE_INFO: return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
7333 case BFD_QNT_CORE_STATUS: return elfcore_grok_nto_status (abfd, note, &tid);
7334 case BFD_QNT_CORE_GREG: return elfcore_grok_nto_gregs (abfd, note, tid);
7335 case BFD_QNT_CORE_FPREG: return elfcore_grok_prfpreg (abfd, note);
7336 default: return TRUE;
7337 }
7338}
7339
7c76fa91
MS		 7340/* Function: elfcore_write_note
7341
47d9a591 7342 Inputs:
7c76fa91
MS		 7343 buffer to hold note
7344 name of note
7345 type of note
7346 data for note
7347 size of data for note
7348
7349 Return:
7350 End of buffer containing note. */
7351
7352char *
217aa764
AM		 7353elfcore_write_note (bfd *abfd,
7354 char *buf,
7355 int *bufsiz,
7356 const char *name,
7357 int type,
7358 const void *input,
7359 int size)
7c76fa91
MS		 7360{
7361 Elf_External_Note *xnp;
d4c88bbb
AM		 7362 size_t namesz;
7363 size_t pad;
7364 size_t newspace;
7c76fa91
MS		 7365 char *p, *dest;
7366
d4c88bbb
AM		 7367 namesz = 0;
7368 pad = 0;
7369 if (name != NULL)
7370 {
9c5bfbb7 7371 const struct elf_backend_data *bed;
d4c88bbb
AM		 7372
7373 namesz = strlen (name) + 1;
7374 bed = get_elf_backend_data (abfd);
45d6a902 7375 pad = -namesz & ((1 << bed->s->log_file_align) - 1);
d4c88bbb
AM		 7376 }
7377
5de3bf90 7378 newspace = 12 + namesz + pad + size;
d4c88bbb 7379
7c76fa91
MS		 7380 p = realloc (buf, *bufsiz + newspace);
7381 dest = p + *bufsiz;
7382 *bufsiz += newspace;
7383 xnp = (Elf_External_Note *) dest;
7384 H_PUT_32 (abfd, namesz, xnp->namesz);
7385 H_PUT_32 (abfd, size, xnp->descsz);
7386 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM		 7387 dest = xnp->name;
7388 if (name != NULL)
7389 {
7390 memcpy (dest, name, namesz);
7391 dest += namesz;
7392 while (pad != 0)
7393 {
7394 *dest++ = '\0';
7395 --pad;
7396 }
7397 }
7398 memcpy (dest, input, size);
7c76fa91
MS		 7399 return p;
7400}
7401
7402#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
7403char *
217aa764
AM		 7404elfcore_write_prpsinfo (bfd *abfd,
7405 char *buf,
7406 int *bufsiz,
7407 const char *fname,
7408 const char *psargs)
7c76fa91
MS		 7409{
7410 int note_type;
7411 char *note_name = "CORE";
7412
7413#if defined (HAVE_PSINFO_T)
7414 psinfo_t data;
7415 note_type = NT_PSINFO;
7416#else
7417 prpsinfo_t data;
7418 note_type = NT_PRPSINFO;
7419#endif
7420
7421 memset (&data, 0, sizeof (data));
7422 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
7423 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
47d9a591 7424 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 7425 note_name, note_type, &data, sizeof (data));
7426}
7427#endif /* PSINFO_T or PRPSINFO_T */
7428
7429#if defined (HAVE_PRSTATUS_T)
7430char *
217aa764
AM		 7431elfcore_write_prstatus (bfd *abfd,
7432 char *buf,
7433 int *bufsiz,
7434 long pid,
7435 int cursig,
7436 const void *gregs)
7c76fa91
MS		 7437{
7438 prstatus_t prstat;
7439 char *note_name = "CORE";
7440
7441 memset (&prstat, 0, sizeof (prstat));
7442 prstat.pr_pid = pid;
7443 prstat.pr_cursig = cursig;
c106e334 7444 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
47d9a591 7445 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 7446 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
7447}
7448#endif /* HAVE_PRSTATUS_T */
7449
51316059
MS		 7450#if defined (HAVE_LWPSTATUS_T)
7451char *
217aa764
AM		 7452elfcore_write_lwpstatus (bfd *abfd,
7453 char *buf,
7454 int *bufsiz,
7455 long pid,
7456 int cursig,
7457 const void *gregs)
51316059
MS		 7458{
7459 lwpstatus_t lwpstat;
7460 char *note_name = "CORE";
7461
7462 memset (&lwpstat, 0, sizeof (lwpstat));
7463 lwpstat.pr_lwpid = pid >> 16;
7464 lwpstat.pr_cursig = cursig;
7465#if defined (HAVE_LWPSTATUS_T_PR_REG)
7466 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
7467#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
7468#if !defined(gregs)
7469 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
7470 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
7471#else
7472 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
7473 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
7474#endif
7475#endif
47d9a591 7476 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 7477 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
7478}
7479#endif /* HAVE_LWPSTATUS_T */
7480
7c76fa91
MS		 7481#if defined (HAVE_PSTATUS_T)
7482char *
217aa764
AM		 7483elfcore_write_pstatus (bfd *abfd,
7484 char *buf,
7485 int *bufsiz,
7486 long pid,
7487 int cursig,
7488 const void *gregs)
7c76fa91
MS		 7489{
7490 pstatus_t pstat;
7491 char *note_name = "CORE";
7492
51316059
MS		 7493 memset (&pstat, 0, sizeof (pstat));
7494 pstat.pr_pid = pid & 0xffff;
47d9a591 7495 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 7496 NT_PSTATUS, &pstat, sizeof (pstat));
7497 return buf;
7c76fa91
MS		 7498}
7499#endif /* HAVE_PSTATUS_T */
7500
7501char *
217aa764
AM		 7502elfcore_write_prfpreg (bfd *abfd,
7503 char *buf,
7504 int *bufsiz,
7505 const void *fpregs,
7506 int size)
7c76fa91
MS		 7507{
7508 char *note_name = "CORE";
47d9a591 7509 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 7510 note_name, NT_FPREGSET, fpregs, size);
7511}
7512
7513char *
217aa764
AM		 7514elfcore_write_prxfpreg (bfd *abfd,
7515 char *buf,
7516 int *bufsiz,
7517 const void *xfpregs,
7518 int size)
7c76fa91
MS		 7519{
7520 char *note_name = "LINUX";
47d9a591 7521 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 7522 note_name, NT_PRXFPREG, xfpregs, size);
7523}
7524
b34976b6 7525static bfd_boolean
217aa764 7526elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
252b5132 7527{
c044fabd
KH		 7528 char *buf;
7529 char *p;
252b5132
RH		 7530
7531 if (size <= 0)
b34976b6 7532 return TRUE;
252b5132 7533
dc810e39 7534 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
b34976b6 7535 return FALSE;
252b5132 7536
dc810e39 7537 buf = bfd_malloc (size);
252b5132 7538 if (buf == NULL)
b34976b6 7539 return FALSE;
252b5132 7540
dc810e39 7541 if (bfd_bread (buf, size, abfd) != size)
252b5132
RH		 7542 {
7543 error:
7544 free (buf);
b34976b6 7545 return FALSE;
252b5132
RH		 7546 }
7547
7548 p = buf;
7549 while (p < buf + size)
7550 {
c044fabd
KH		 7551 /* FIXME: bad alignment assumption. */
7552 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH		 7553 Elf_Internal_Note in;
7554
dc810e39 7555 in.type = H_GET_32 (abfd, xnp->type);
252b5132 7556
dc810e39 7557 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132
RH		 7558 in.namedata = xnp->name;
7559
dc810e39 7560 in.descsz = H_GET_32 (abfd, xnp->descsz);
252b5132
RH		 7561 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
7562 in.descpos = offset + (in.descdata - buf);
7563
50b2bdb7
AM		 7564 if (strncmp (in.namedata, "NetBSD-CORE", 11) == 0)
7565 {
7566 if (! elfcore_grok_netbsd_note (abfd, &in))
7567 goto error;
7568 }
07c6e936
NC		 7569 else if (strncmp (in.namedata, "QNX", 3) == 0)
7570 {
7571 if (! elfcore_grok_nto_note (abfd, &in))
7572 goto error;
7573 }
50b2bdb7
AM		 7574 else
7575 {
7576 if (! elfcore_grok_note (abfd, &in))
7577 goto error;
7578 }
252b5132
RH		 7579
7580 p = in.descdata + BFD_ALIGN (in.descsz, 4);
7581 }
7582
7583 free (buf);
b34976b6 7584 return TRUE;
252b5132 7585}
98d8431c
JB		 7586\f
7587/* Providing external access to the ELF program header table. */
7588
7589/* Return an upper bound on the number of bytes required to store a
7590 copy of ABFD's program header table entries. Return -1 if an error
7591 occurs; bfd_get_error will return an appropriate code. */
c044fabd 7592
98d8431c 7593long
217aa764 7594bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB		 7595{
7596 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7597 {
7598 bfd_set_error (bfd_error_wrong_format);
7599 return -1;
7600 }
7601
936e320b 7602 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB		 7603}
7604
98d8431c
JB		 7605/* Copy ABFD's program header table entries to *PHDRS. The entries
7606 will be stored as an array of Elf_Internal_Phdr structures, as
7607 defined in include/elf/internal.h. To find out how large the
7608 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
7609
7610 Return the number of program header table entries read, or -1 if an
7611 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 7612
98d8431c 7613int
217aa764 7614bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB		 7615{
7616 int num_phdrs;
7617
7618 if (abfd->xvec->flavour != bfd_target_elf_flavour)
7619 {
7620 bfd_set_error (bfd_error_wrong_format);
7621 return -1;
7622 }
7623
7624 num_phdrs = elf_elfheader (abfd)->e_phnum;
c044fabd 7625 memcpy (phdrs, elf_tdata (abfd)->phdr,
98d8431c
JB		 7626 num_phdrs * sizeof (Elf_Internal_Phdr));
7627
7628 return num_phdrs;
7629}
ae4221d7
L		 7630
7631void
217aa764 7632_bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
ae4221d7 7633{
d3b05f8d 7634#ifdef BFD64
ae4221d7
L		 7635 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7636
7637 i_ehdrp = elf_elfheader (abfd);
7638 if (i_ehdrp == NULL)
7639 sprintf_vma (buf, value);
7640 else
7641 {
7642 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
cc55aec9 7643 {
ae4221d7 7644#if BFD_HOST_64BIT_LONG
cc55aec9 7645 sprintf (buf, "%016lx", value);
ae4221d7 7646#else
cc55aec9
AM		 7647 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
7648 _bfd_int64_low (value));
ae4221d7 7649#endif
cc55aec9 7650 }
ae4221d7
L		 7651 else
7652 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
7653 }
d3b05f8d
L		 7654#else
7655 sprintf_vma (buf, value);
7656#endif
ae4221d7
L		 7657}
7658
7659void
217aa764 7660_bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
ae4221d7 7661{
d3b05f8d 7662#ifdef BFD64
ae4221d7
L		 7663 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
7664
7665 i_ehdrp = elf_elfheader (abfd);
7666 if (i_ehdrp == NULL)
7667 fprintf_vma ((FILE *) stream, value);
7668 else
7669 {
7670 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
cc55aec9 7671 {
ae4221d7 7672#if BFD_HOST_64BIT_LONG
cc55aec9 7673 fprintf ((FILE *) stream, "%016lx", value);
ae4221d7 7674#else
cc55aec9
AM		 7675 fprintf ((FILE *) stream, "%08lx%08lx",
7676 _bfd_int64_high (value), _bfd_int64_low (value));
ae4221d7 7677#endif
cc55aec9 7678 }
ae4221d7
L		 7679 else
7680 fprintf ((FILE *) stream, "%08lx",
7681 (unsigned long) (value & 0xffffffff));
7682 }
d3b05f8d
L		 7683#else
7684 fprintf_vma ((FILE *) stream, value);
7685#endif
ae4221d7 7686}
db6751f2
JJ		 7687
7688enum elf_reloc_type_class
217aa764 7689_bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ		 7690{
7691 return reloc_class_normal;
7692}
f8df10f4 7693
47d9a591 7694/* For RELA architectures, return the relocation value for a
f8df10f4
JJ		 7695 relocation against a local symbol. */
7696
7697bfd_vma
217aa764
AM		 7698_bfd_elf_rela_local_sym (bfd *abfd,
7699 Elf_Internal_Sym *sym,
8517fae7 7700 asection **psec,
217aa764 7701 Elf_Internal_Rela *rel)
f8df10f4 7702{
8517fae7 7703 asection *sec = *psec;
f8df10f4
JJ		 7704 bfd_vma relocation;
7705
7706 relocation = (sec->output_section->vma
7707 + sec->output_offset
7708 + sym->st_value);
7709 if ((sec->flags & SEC_MERGE)
c629eae0 7710 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
68bfbfcc 7711 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
f8df10f4 7712 {
f8df10f4 7713 rel->r_addend =
8517fae7 7714 _bfd_merged_section_offset (abfd, psec,
65765700 7715 elf_section_data (sec)->sec_info,
753731ee
AM		 7716 sym->st_value + rel->r_addend);
7717 if (sec != *psec)
7718 {
7719 /* If we have changed the section, and our original section is
7720 marked with SEC_EXCLUDE, it means that the original
7721 SEC_MERGE section has been completely subsumed in some
7722 other SEC_MERGE section. In this case, we need to leave
7723 some info around for --emit-relocs. */
7724 if ((sec->flags & SEC_EXCLUDE) != 0)
7725 sec->kept_section = *psec;
7726 sec = *psec;
7727 }
8517fae7
AM		 7728 rel->r_addend -= relocation;
7729 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ		 7730 }
7731 return relocation;
7732}
c629eae0
JJ		 7733
7734bfd_vma
217aa764
AM		 7735_bfd_elf_rel_local_sym (bfd *abfd,
7736 Elf_Internal_Sym *sym,
7737 asection **psec,
7738 bfd_vma addend)
47d9a591 7739{
c629eae0
JJ		 7740 asection *sec = *psec;
7741
68bfbfcc 7742 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
c629eae0
JJ		 7743 return sym->st_value + addend;
7744
7745 return _bfd_merged_section_offset (abfd, psec,
65765700 7746 elf_section_data (sec)->sec_info,
753731ee 7747 sym->st_value + addend);
c629eae0
JJ		 7748}
7749
7750bfd_vma
217aa764 7751_bfd_elf_section_offset (bfd *abfd,
92e4ec35 7752 struct bfd_link_info *info,
217aa764
AM		 7753 asection *sec,
7754 bfd_vma offset)
c629eae0 7755{
68bfbfcc 7756 switch (sec->sec_info_type)
65765700
JJ		 7757 {
7758 case ELF_INFO_TYPE_STABS:
eea6121a
AM		 7759 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
7760 offset);
65765700 7761 case ELF_INFO_TYPE_EH_FRAME:
92e4ec35 7762 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
65765700
JJ		 7763 default:
7764 return offset;
7765 }
c629eae0 7766}
3333a7c3
RM		 7767\f
7768/* Create a new BFD as if by bfd_openr. Rather than opening a file,
7769 reconstruct an ELF file by reading the segments out of remote memory
7770 based on the ELF file header at EHDR_VMA and the ELF program headers it
7771 points to. If not null, *LOADBASEP is filled in with the difference
7772 between the VMAs from which the segments were read, and the VMAs the
7773 file headers (and hence BFD's idea of each section's VMA) put them at.
7774
7775 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
7776 remote memory at target address VMA into the local buffer at MYADDR; it
7777 should return zero on success or an `errno' code on failure. TEMPL must
7778 be a BFD for an ELF target with the word size and byte order found in
7779 the remote memory. */
7780
7781bfd *
217aa764
AM		 7782bfd_elf_bfd_from_remote_memory
7783 (bfd *templ,
7784 bfd_vma ehdr_vma,
7785 bfd_vma *loadbasep,
7786 int (*target_read_memory) (bfd_vma, char *, int))
3333a7c3
RM		 7787{
7788 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
7789 (templ, ehdr_vma, loadbasep, target_read_memory);
7790}
4c45e5c9
JJ		 7791\f
7792long
c9727e01
AM		 7793_bfd_elf_get_synthetic_symtab (bfd *abfd,
7794 long symcount ATTRIBUTE_UNUSED,
7795 asymbol **syms ATTRIBUTE_UNUSED,
7796 long dynsymcount ATTRIBUTE_UNUSED,
7797 asymbol **dynsyms,
7798 asymbol **ret)
4c45e5c9
JJ		 7799{
7800 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7801 asection *relplt;
7802 asymbol *s;
7803 const char *relplt_name;
7804 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
7805 arelent *p;
7806 long count, i, n;
7807 size_t size;
7808 Elf_Internal_Shdr *hdr;
7809 char *names;
7810 asection *plt;
7811
90e3cdf2
JJ		 7812 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
7813 return 0;
7814
4c45e5c9
JJ		 7815 *ret = NULL;
7816 if (!bed->plt_sym_val)
7817 return 0;
7818
7819 relplt_name = bed->relplt_name;
7820 if (relplt_name == NULL)
7821 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
7822 relplt = bfd_get_section_by_name (abfd, relplt_name);
7823 if (relplt == NULL)
7824 return 0;
7825
7826 hdr = &elf_section_data (relplt)->this_hdr;
7827 if (hdr->sh_link != elf_dynsymtab (abfd)
7828 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
7829 return 0;
7830
7831 plt = bfd_get_section_by_name (abfd, ".plt");
7832 if (plt == NULL)
7833 return 0;
7834
7835 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 7836 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ		 7837 return -1;
7838
eea6121a 7839 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ		 7840 size = count * sizeof (asymbol);
7841 p = relplt->relocation;
7842 for (i = 0; i < count; i++, s++, p++)
7843 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
7844
7845 s = *ret = bfd_malloc (size);
7846 if (s == NULL)
7847 return -1;
7848
7849 names = (char *) (s + count);
7850 p = relplt->relocation;
7851 n = 0;
7852 for (i = 0; i < count; i++, s++, p++)
7853 {
7854 size_t len;
7855 bfd_vma addr;
7856
7857 addr = bed->plt_sym_val (i, plt, p);
7858 if (addr == (bfd_vma) -1)
7859 continue;
7860
7861 *s = **p->sym_ptr_ptr;
7862 s->section = plt;
7863 s->value = addr - plt->vma;
7864 s->name = names;
7865 len = strlen ((*p->sym_ptr_ptr)->name);
7866 memcpy (names, (*p->sym_ptr_ptr)->name, len);
7867 names += len;
7868 memcpy (names, "@plt", sizeof ("@plt"));
7869 names += sizeof ("@plt");
7870 ++n;
7871 }
7872
7873 return n;
7874}
3d7f7666
L		 7875
7876/* Sort symbol by binding and section. We want to put definitions
7877 sorted by section at the beginning. */
7878
7879static int
7880elf_sort_elf_symbol (const void *arg1, const void *arg2)
7881{
7882 const Elf_Internal_Sym *s1;
7883 const Elf_Internal_Sym *s2;
7884 int shndx;
7885
7886 /* Make sure that undefined symbols are at the end. */
7887 s1 = (const Elf_Internal_Sym *) arg1;
7888 if (s1->st_shndx == SHN_UNDEF)
7889 return 1;
7890 s2 = (const Elf_Internal_Sym *) arg2;
7891 if (s2->st_shndx == SHN_UNDEF)
7892 return -1;
7893
7894 /* Sorted by section index. */
7895 shndx = s1->st_shndx - s2->st_shndx;
7896 if (shndx != 0)
7897 return shndx;
7898
7899 /* Sorted by binding. */
7900 return ELF_ST_BIND (s1->st_info) - ELF_ST_BIND (s2->st_info);
7901}
7902
7903struct elf_symbol
7904{
7905 Elf_Internal_Sym *sym;
7906 const char *name;
7907};
7908
7909static int
7910elf_sym_name_compare (const void *arg1, const void *arg2)
7911{
7912 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
7913 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
7914 return strcmp (s1->name, s2->name);
7915}
7916
7917/* Check if 2 sections define the same set of local and global
7918 symbols. */
7919
7920bfd_boolean
7921bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2)
7922{
7923 bfd *bfd1, *bfd2;
7924 const struct elf_backend_data *bed1, *bed2;
7925 Elf_Internal_Shdr *hdr1, *hdr2;
7926 bfd_size_type symcount1, symcount2;
7927 Elf_Internal_Sym *isymbuf1, *isymbuf2;
7928 Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
7929 Elf_Internal_Sym *isymend;
7930 struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
7931 bfd_size_type count1, count2, i;
7932 int shndx1, shndx2;
7933 bfd_boolean result;
7934
7935 bfd1 = sec1->owner;
7936 bfd2 = sec2->owner;
7937
7938 /* If both are .gnu.linkonce sections, they have to have the same
7939 section name. */
7940 if (strncmp (sec1->name, ".gnu.linkonce",
7941 sizeof ".gnu.linkonce" - 1) == 0
7942 && strncmp (sec2->name, ".gnu.linkonce",
7943 sizeof ".gnu.linkonce" - 1) == 0)
7944 return strcmp (sec1->name + sizeof ".gnu.linkonce",
7945 sec2->name + sizeof ".gnu.linkonce") == 0;
7946
7947 /* Both sections have to be in ELF. */
7948 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
7949 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
7950 return FALSE;
7951
7952 if (elf_section_type (sec1) != elf_section_type (sec2))
7953 return FALSE;
7954
7955 if ((elf_section_flags (sec1) & SHF_GROUP) != 0
7956 && (elf_section_flags (sec2) & SHF_GROUP) != 0)
7957 {
7958 /* If both are members of section groups, they have to have the
7959 same group name. */
7960 if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
7961 return FALSE;
7962 }
7963
7964 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
7965 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
7966 if (shndx1 == -1 || shndx2 == -1)
7967 return FALSE;
7968
7969 bed1 = get_elf_backend_data (bfd1);
7970 bed2 = get_elf_backend_data (bfd2);
7971 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
7972 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
7973 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
7974 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
7975
7976 if (symcount1 == 0 || symcount2 == 0)
7977 return FALSE;
7978
7979 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
7980 NULL, NULL, NULL);
7981 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
7982 NULL, NULL, NULL);
7983
7984 result = FALSE;
7985 if (isymbuf1 == NULL || isymbuf2 == NULL)
7986 goto done;
7987
7988 /* Sort symbols by binding and section. Global definitions are at
7989 the beginning. */
7990 qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
7991 elf_sort_elf_symbol);
7992 qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
7993 elf_sort_elf_symbol);
7994
7995 /* Count definitions in the section. */
7996 count1 = 0;
7997 for (isym = isymbuf1, isymend = isym + symcount1;
7998 isym < isymend; isym++)
7999 {
8000 if (isym->st_shndx == (unsigned int) shndx1)
8001 {
8002 if (count1 == 0)
8003 isymstart1 = isym;
8004 count1++;
8005 }
8006
8007 if (count1 && isym->st_shndx != (unsigned int) shndx1)
8008 break;
8009 }
8010
8011 count2 = 0;
8012 for (isym = isymbuf2, isymend = isym + symcount2;
8013 isym < isymend; isym++)
8014 {
8015 if (isym->st_shndx == (unsigned int) shndx2)
8016 {
8017 if (count2 == 0)
8018 isymstart2 = isym;
8019 count2++;
8020 }
8021
8022 if (count2 && isym->st_shndx != (unsigned int) shndx2)
8023 break;
8024 }
8025
8026 if (count1 == 0 || count2 == 0 || count1 != count2)
8027 goto done;
8028
8029 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8030 symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8031
8032 if (symtable1 == NULL || symtable2 == NULL)
8033 goto done;
8034
8035 symp = symtable1;
8036 for (isym = isymstart1, isymend = isym + count1;
8037 isym < isymend; isym++)
8038 {
8039 symp->sym = isym;
8040 symp->name = bfd_elf_string_from_elf_section (bfd1,
8041 hdr1->sh_link,
8042 isym->st_name);
8043 symp++;
8044 }
8045
8046 symp = symtable2;
8047 for (isym = isymstart2, isymend = isym + count1;
8048 isym < isymend; isym++)
8049 {
8050 symp->sym = isym;
8051 symp->name = bfd_elf_string_from_elf_section (bfd2,
8052 hdr2->sh_link,
8053 isym->st_name);
8054 symp++;
8055 }
8056
8057 /* Sort symbol by name. */
8058 qsort (symtable1, count1, sizeof (struct elf_symbol),
8059 elf_sym_name_compare);
8060 qsort (symtable2, count1, sizeof (struct elf_symbol),
8061 elf_sym_name_compare);
8062
8063 for (i = 0; i < count1; i++)
8064 /* Two symbols must have the same binding, type and name. */
8065 if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8066 || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8067 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
8068 goto done;
8069
8070 result = TRUE;
8071
8072done:
8073 if (symtable1)
8074 free (symtable1);
8075 if (symtable2)
8076 free (symtable2);
8077 if (isymbuf1)
8078 free (isymbuf1);
8079 if (isymbuf2)
8080 free (isymbuf2);
8081
8082 return result;
8083}
GDB Binutils - Deliverables
This page took 1.604276 seconds and 4 git commands to generate.