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