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