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