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