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