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