projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
daily update
[deliverable/binutils-gdb.git] / bfd / elf.c
CommitLineData
252b5132 1/* ELF executable support for BFD.
340b6d91
AC		 2
3 Copyright 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
fad2f28d 4 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
252b5132 5
5e8d7549 6 This file is part of BFD, the Binary File Descriptor library.
252b5132 7
5e8d7549
NC		 8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
252b5132 12
5e8d7549
NC		 13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
252b5132 17
5e8d7549 18 You should have received a copy of the GNU General Public License
b34976b6 19 along with this program; if not, write to the Free Software
3e110533 20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
252b5132 21
1b74d094
BW		 22/*
23SECTION
252b5132
RH		 24 ELF backends
25
26 BFD support for ELF formats is being worked on.
27 Currently, the best supported back ends are for sparc and i386
28 (running svr4 or Solaris 2).
29
30 Documentation of the internals of the support code still needs
31 to be written. The code is changing quickly enough that we
661a3fd4 32 haven't bothered yet. */
252b5132 33
7ee38065
MS		 34/* For sparc64-cross-sparc32. */
35#define _SYSCALL32
252b5132
RH		 36#include "bfd.h"
37#include "sysdep.h"
38#include "bfdlink.h"
39#include "libbfd.h"
40#define ARCH_SIZE 0
41#include "elf-bfd.h"
e0e8c97f 42#include "libiberty.h"
252b5132 43
217aa764 44static int elf_sort_sections (const void *, const void *);
c84fca4d 45static bfd_boolean assign_file_positions_except_relocs (bfd *, struct bfd_link_info *);
217aa764
AM		 46static bfd_boolean prep_headers (bfd *);
47static bfd_boolean swap_out_syms (bfd *, struct bfd_strtab_hash **, int) ;
48static bfd_boolean elfcore_read_notes (bfd *, file_ptr, bfd_size_type) ;
50b2bdb7 49
252b5132
RH		 50/* Swap version information in and out. The version information is
51 currently size independent. If that ever changes, this code will
52 need to move into elfcode.h. */
53
54/* Swap in a Verdef structure. */
55
56void
217aa764
AM		 57_bfd_elf_swap_verdef_in (bfd *abfd,
58 const Elf_External_Verdef *src,
59 Elf_Internal_Verdef *dst)
252b5132 60{
dc810e39
AM		 61 dst->vd_version = H_GET_16 (abfd, src->vd_version);
62 dst->vd_flags = H_GET_16 (abfd, src->vd_flags);
63 dst->vd_ndx = H_GET_16 (abfd, src->vd_ndx);
64 dst->vd_cnt = H_GET_16 (abfd, src->vd_cnt);
65 dst->vd_hash = H_GET_32 (abfd, src->vd_hash);
66 dst->vd_aux = H_GET_32 (abfd, src->vd_aux);
67 dst->vd_next = H_GET_32 (abfd, src->vd_next);
252b5132
RH		 68}
69
70/* Swap out a Verdef structure. */
71
72void
217aa764
AM		 73_bfd_elf_swap_verdef_out (bfd *abfd,
74 const Elf_Internal_Verdef *src,
75 Elf_External_Verdef *dst)
252b5132 76{
dc810e39
AM		 77 H_PUT_16 (abfd, src->vd_version, dst->vd_version);
78 H_PUT_16 (abfd, src->vd_flags, dst->vd_flags);
79 H_PUT_16 (abfd, src->vd_ndx, dst->vd_ndx);
80 H_PUT_16 (abfd, src->vd_cnt, dst->vd_cnt);
81 H_PUT_32 (abfd, src->vd_hash, dst->vd_hash);
82 H_PUT_32 (abfd, src->vd_aux, dst->vd_aux);
83 H_PUT_32 (abfd, src->vd_next, dst->vd_next);
252b5132
RH		 84}
85
86/* Swap in a Verdaux structure. */
87
88void
217aa764
AM		 89_bfd_elf_swap_verdaux_in (bfd *abfd,
90 const Elf_External_Verdaux *src,
91 Elf_Internal_Verdaux *dst)
252b5132 92{
dc810e39
AM		 93 dst->vda_name = H_GET_32 (abfd, src->vda_name);
94 dst->vda_next = H_GET_32 (abfd, src->vda_next);
252b5132
RH		 95}
96
97/* Swap out a Verdaux structure. */
98
99void
217aa764
AM		 100_bfd_elf_swap_verdaux_out (bfd *abfd,
101 const Elf_Internal_Verdaux *src,
102 Elf_External_Verdaux *dst)
252b5132 103{
dc810e39
AM		 104 H_PUT_32 (abfd, src->vda_name, dst->vda_name);
105 H_PUT_32 (abfd, src->vda_next, dst->vda_next);
252b5132
RH		 106}
107
108/* Swap in a Verneed structure. */
109
110void
217aa764
AM		 111_bfd_elf_swap_verneed_in (bfd *abfd,
112 const Elf_External_Verneed *src,
113 Elf_Internal_Verneed *dst)
252b5132 114{
dc810e39
AM		 115 dst->vn_version = H_GET_16 (abfd, src->vn_version);
116 dst->vn_cnt = H_GET_16 (abfd, src->vn_cnt);
117 dst->vn_file = H_GET_32 (abfd, src->vn_file);
118 dst->vn_aux = H_GET_32 (abfd, src->vn_aux);
119 dst->vn_next = H_GET_32 (abfd, src->vn_next);
252b5132
RH		 120}
121
122/* Swap out a Verneed structure. */
123
124void
217aa764
AM		 125_bfd_elf_swap_verneed_out (bfd *abfd,
126 const Elf_Internal_Verneed *src,
127 Elf_External_Verneed *dst)
252b5132 128{
dc810e39
AM		 129 H_PUT_16 (abfd, src->vn_version, dst->vn_version);
130 H_PUT_16 (abfd, src->vn_cnt, dst->vn_cnt);
131 H_PUT_32 (abfd, src->vn_file, dst->vn_file);
132 H_PUT_32 (abfd, src->vn_aux, dst->vn_aux);
133 H_PUT_32 (abfd, src->vn_next, dst->vn_next);
252b5132
RH		 134}
135
136/* Swap in a Vernaux structure. */
137
138void
217aa764
AM		 139_bfd_elf_swap_vernaux_in (bfd *abfd,
140 const Elf_External_Vernaux *src,
141 Elf_Internal_Vernaux *dst)
252b5132 142{
dc810e39
AM		 143 dst->vna_hash = H_GET_32 (abfd, src->vna_hash);
144 dst->vna_flags = H_GET_16 (abfd, src->vna_flags);
145 dst->vna_other = H_GET_16 (abfd, src->vna_other);
146 dst->vna_name = H_GET_32 (abfd, src->vna_name);
147 dst->vna_next = H_GET_32 (abfd, src->vna_next);
252b5132
RH		 148}
149
150/* Swap out a Vernaux structure. */
151
152void
217aa764
AM		 153_bfd_elf_swap_vernaux_out (bfd *abfd,
154 const Elf_Internal_Vernaux *src,
155 Elf_External_Vernaux *dst)
252b5132 156{
dc810e39
AM		 157 H_PUT_32 (abfd, src->vna_hash, dst->vna_hash);
158 H_PUT_16 (abfd, src->vna_flags, dst->vna_flags);
159 H_PUT_16 (abfd, src->vna_other, dst->vna_other);
160 H_PUT_32 (abfd, src->vna_name, dst->vna_name);
161 H_PUT_32 (abfd, src->vna_next, dst->vna_next);
252b5132
RH		 162}
163
164/* Swap in a Versym structure. */
165
166void
217aa764
AM		 167_bfd_elf_swap_versym_in (bfd *abfd,
168 const Elf_External_Versym *src,
169 Elf_Internal_Versym *dst)
252b5132 170{
dc810e39 171 dst->vs_vers = H_GET_16 (abfd, src->vs_vers);
252b5132
RH		 172}
173
174/* Swap out a Versym structure. */
175
176void
217aa764
AM		 177_bfd_elf_swap_versym_out (bfd *abfd,
178 const Elf_Internal_Versym *src,
179 Elf_External_Versym *dst)
252b5132 180{
dc810e39 181 H_PUT_16 (abfd, src->vs_vers, dst->vs_vers);
252b5132
RH		 182}
183
184/* Standard ELF hash function. Do not change this function; you will
185 cause invalid hash tables to be generated. */
3a99b017 186
252b5132 187unsigned long
217aa764 188bfd_elf_hash (const char *namearg)
252b5132 189{
3a99b017 190 const unsigned char *name = (const unsigned char *) namearg;
252b5132
RH		 191 unsigned long h = 0;
192 unsigned long g;
193 int ch;
194
195 while ((ch = *name++) != '\0')
196 {
197 h = (h << 4) + ch;
198 if ((g = (h & 0xf0000000)) != 0)
199 {
200 h ^= g >> 24;
201 /* The ELF ABI says `h &= ~g', but this is equivalent in
202 this case and on some machines one insn instead of two. */
203 h ^= g;
204 }
205 }
32dfa85d 206 return h & 0xffffffff;
252b5132
RH		 207}
208
fdc90cb4
JJ		 209/* DT_GNU_HASH hash function. Do not change this function; you will
210 cause invalid hash tables to be generated. */
211
212unsigned long
213bfd_elf_gnu_hash (const char *namearg)
214{
215 const unsigned char *name = (const unsigned char *) namearg;
216 unsigned long h = 5381;
217 unsigned char ch;
218
219 while ((ch = *name++) != '\0')
220 h = (h << 5) + h + ch;
221 return h & 0xffffffff;
222}
223
b34976b6 224bfd_boolean
217aa764 225bfd_elf_mkobject (bfd *abfd)
252b5132 226{
62d7a5f6
AM		 227 if (abfd->tdata.any == NULL)
228 {
229 abfd->tdata.any = bfd_zalloc (abfd, sizeof (struct elf_obj_tdata));
230 if (abfd->tdata.any == NULL)
231 return FALSE;
232 }
233
234 elf_tdata (abfd)->program_header_size = (bfd_size_type) -1;
252b5132 235
b34976b6 236 return TRUE;
252b5132
RH		 237}
238
b34976b6 239bfd_boolean
217aa764 240bfd_elf_mkcorefile (bfd *abfd)
252b5132 241{
c044fabd 242 /* I think this can be done just like an object file. */
252b5132
RH		 243 return bfd_elf_mkobject (abfd);
244}
245
246char *
217aa764 247bfd_elf_get_str_section (bfd *abfd, unsigned int shindex)
252b5132
RH		 248{
249 Elf_Internal_Shdr **i_shdrp;
f075ee0c 250 bfd_byte *shstrtab = NULL;
dc810e39
AM		 251 file_ptr offset;
252 bfd_size_type shstrtabsize;
252b5132
RH		 253
254 i_shdrp = elf_elfsections (abfd);
255 if (i_shdrp == 0 || i_shdrp[shindex] == 0)
f075ee0c 256 return NULL;
252b5132 257
f075ee0c 258 shstrtab = i_shdrp[shindex]->contents;
252b5132
RH		 259 if (shstrtab == NULL)
260 {
c044fabd 261 /* No cached one, attempt to read, and cache what we read. */
252b5132
RH		 262 offset = i_shdrp[shindex]->sh_offset;
263 shstrtabsize = i_shdrp[shindex]->sh_size;
c6c60d09
JJ		 264
265 /* Allocate and clear an extra byte at the end, to prevent crashes
266 in case the string table is not terminated. */
267 if (shstrtabsize + 1 == 0
268 || (shstrtab = bfd_alloc (abfd, shstrtabsize + 1)) == NULL
269 || bfd_seek (abfd, offset, SEEK_SET) != 0)
270 shstrtab = NULL;
271 else if (bfd_bread (shstrtab, shstrtabsize, abfd) != shstrtabsize)
272 {
273 if (bfd_get_error () != bfd_error_system_call)
274 bfd_set_error (bfd_error_file_truncated);
275 shstrtab = NULL;
276 }
277 else
278 shstrtab[shstrtabsize] = '\0';
217aa764 279 i_shdrp[shindex]->contents = shstrtab;
252b5132 280 }
f075ee0c 281 return (char *) shstrtab;
252b5132
RH		 282}
283
284char *
217aa764
AM		 285bfd_elf_string_from_elf_section (bfd *abfd,
286 unsigned int shindex,
287 unsigned int strindex)
252b5132
RH		 288{
289 Elf_Internal_Shdr *hdr;
290
291 if (strindex == 0)
292 return "";
293
294 hdr = elf_elfsections (abfd)[shindex];
295
296 if (hdr->contents == NULL
297 && bfd_elf_get_str_section (abfd, shindex) == NULL)
298 return NULL;
299
300 if (strindex >= hdr->sh_size)
301 {
1b3a8575 302 unsigned int shstrndx = elf_elfheader(abfd)->e_shstrndx;
252b5132 303 (*_bfd_error_handler)
d003868e
AM		 304 (_("%B: invalid string offset %u >= %lu for section `%s'"),
305 abfd, strindex, (unsigned long) hdr->sh_size,
1b3a8575 306 (shindex == shstrndx && strindex == hdr->sh_name
252b5132 307 ? ".shstrtab"
1b3a8575 308 : bfd_elf_string_from_elf_section (abfd, shstrndx, hdr->sh_name)));
252b5132
RH		 309 return "";
310 }
311
312 return ((char *) hdr->contents) + strindex;
313}
314
6cdc0ccc
AM		 315/* Read and convert symbols to internal format.
316 SYMCOUNT specifies the number of symbols to read, starting from
317 symbol SYMOFFSET. If any of INTSYM_BUF, EXTSYM_BUF or EXTSHNDX_BUF
318 are non-NULL, they are used to store the internal symbols, external
319 symbols, and symbol section index extensions, respectively. */
320
321Elf_Internal_Sym *
217aa764
AM		 322bfd_elf_get_elf_syms (bfd *ibfd,
323 Elf_Internal_Shdr *symtab_hdr,
324 size_t symcount,
325 size_t symoffset,
326 Elf_Internal_Sym *intsym_buf,
327 void *extsym_buf,
328 Elf_External_Sym_Shndx *extshndx_buf)
6cdc0ccc
AM		 329{
330 Elf_Internal_Shdr *shndx_hdr;
217aa764 331 void *alloc_ext;
df622259 332 const bfd_byte *esym;
6cdc0ccc
AM		 333 Elf_External_Sym_Shndx *alloc_extshndx;
334 Elf_External_Sym_Shndx *shndx;
335 Elf_Internal_Sym *isym;
336 Elf_Internal_Sym *isymend;
9c5bfbb7 337 const struct elf_backend_data *bed;
6cdc0ccc
AM		 338 size_t extsym_size;
339 bfd_size_type amt;
340 file_ptr pos;
341
342 if (symcount == 0)
343 return intsym_buf;
344
345 /* Normal syms might have section extension entries. */
346 shndx_hdr = NULL;
347 if (symtab_hdr == &elf_tdata (ibfd)->symtab_hdr)
348 shndx_hdr = &elf_tdata (ibfd)->symtab_shndx_hdr;
349
350 /* Read the symbols. */
351 alloc_ext = NULL;
352 alloc_extshndx = NULL;
353 bed = get_elf_backend_data (ibfd);
354 extsym_size = bed->s->sizeof_sym;
355 amt = symcount * extsym_size;
356 pos = symtab_hdr->sh_offset + symoffset * extsym_size;
357 if (extsym_buf == NULL)
358 {
d0fb9a8d 359 alloc_ext = bfd_malloc2 (symcount, extsym_size);
6cdc0ccc
AM		 360 extsym_buf = alloc_ext;
361 }
362 if (extsym_buf == NULL
363 || bfd_seek (ibfd, pos, SEEK_SET) != 0
364 || bfd_bread (extsym_buf, amt, ibfd) != amt)
365 {
366 intsym_buf = NULL;
367 goto out;
368 }
369
370 if (shndx_hdr == NULL || shndx_hdr->sh_size == 0)
371 extshndx_buf = NULL;
372 else
373 {
374 amt = symcount * sizeof (Elf_External_Sym_Shndx);
375 pos = shndx_hdr->sh_offset + symoffset * sizeof (Elf_External_Sym_Shndx);
376 if (extshndx_buf == NULL)
377 {
d0fb9a8d
JJ		 378 alloc_extshndx = bfd_malloc2 (symcount,
379 sizeof (Elf_External_Sym_Shndx));
6cdc0ccc
AM		 380 extshndx_buf = alloc_extshndx;
381 }
382 if (extshndx_buf == NULL
383 || bfd_seek (ibfd, pos, SEEK_SET) != 0
384 || bfd_bread (extshndx_buf, amt, ibfd) != amt)
385 {
386 intsym_buf = NULL;
387 goto out;
388 }
389 }
390
391 if (intsym_buf == NULL)
392 {
d0fb9a8d 393 intsym_buf = bfd_malloc2 (symcount, sizeof (Elf_Internal_Sym));
6cdc0ccc
AM		 394 if (intsym_buf == NULL)
395 goto out;
396 }
397
398 /* Convert the symbols to internal form. */
399 isymend = intsym_buf + symcount;
400 for (esym = extsym_buf, isym = intsym_buf, shndx = extshndx_buf;
401 isym < isymend;
402 esym += extsym_size, isym++, shndx = shndx != NULL ? shndx + 1 : NULL)
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;
9f17e2a6
L		 5430 /* If the first section in the input segment is removed, there is
5431 no need to preserve segment physical address in the corresponding
5432 output segment. */
5433 if (first_section->output_section != NULL)
5434 {
5435 map->p_paddr = segment->p_paddr;
5436 map->p_paddr_valid = 1;
5437 }
252b5132
RH		 5438
5439 /* Determine if this segment contains the ELF file header
5440 and if it contains the program headers themselves. */
bc67d8a6
NC		 5441 map->includes_filehdr = (segment->p_offset == 0
5442 && segment->p_filesz >= iehdr->e_ehsize);
252b5132 5443
bc67d8a6 5444 map->includes_phdrs = 0;
252b5132 5445
bc67d8a6 5446 if (! phdr_included || segment->p_type != PT_LOAD)
252b5132 5447 {
bc67d8a6
NC		 5448 map->includes_phdrs =
5449 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5450 && (segment->p_offset + segment->p_filesz
252b5132
RH		 5451 >= ((bfd_vma) iehdr->e_phoff
5452 + iehdr->e_phnum * iehdr->e_phentsize)));
c044fabd 5453
bc67d8a6 5454 if (segment->p_type == PT_LOAD && map->includes_phdrs)
b34976b6 5455 phdr_included = TRUE;
252b5132
RH		 5456 }
5457
bc67d8a6 5458 if (section_count == 0)
252b5132
RH		 5459 {
5460 /* Special segments, such as the PT_PHDR segment, may contain
5461 no sections, but ordinary, loadable segments should contain
1ed89aa9
NC		 5462 something. They are allowed by the ELF spec however, so only
5463 a warning is produced. */
bc67d8a6 5464 if (segment->p_type == PT_LOAD)
caf47ea6 5465 (*_bfd_error_handler)
d003868e
AM		 5466 (_("%B: warning: Empty loadable segment detected, is this intentional ?\n"),
5467 ibfd);
252b5132 5468
bc67d8a6 5469 map->count = 0;
c044fabd
KH		 5470 *pointer_to_map = map;
5471 pointer_to_map = &map->next;
252b5132
RH		 5472
5473 continue;
5474 }
5475
5476 /* Now scan the sections in the input BFD again and attempt
5477 to add their corresponding output sections to the segment map.
5478 The problem here is how to handle an output section which has
5479 been moved (ie had its LMA changed). There are four possibilities:
5480
5481 1. None of the sections have been moved.
5482 In this case we can continue to use the segment LMA from the
5483 input BFD.
5484
5485 2. All of the sections have been moved by the same amount.
5486 In this case we can change the segment's LMA to match the LMA
5487 of the first section.
5488
5489 3. Some of the sections have been moved, others have not.
5490 In this case those sections which have not been moved can be
5491 placed in the current segment which will have to have its size,
5492 and possibly its LMA changed, and a new segment or segments will
5493 have to be created to contain the other sections.
5494
b5f852ea 5495 4. The sections have been moved, but not by the same amount.
252b5132
RH		 5496 In this case we can change the segment's LMA to match the LMA
5497 of the first section and we will have to create a new segment
5498 or segments to contain the other sections.
5499
5500 In order to save time, we allocate an array to hold the section
5501 pointers that we are interested in. As these sections get assigned
5502 to a segment, they are removed from this array. */
5503
0b14c2aa
L		 5504 /* Gcc 2.96 miscompiles this code on mips. Don't do casting here
5505 to work around this long long bug. */
d0fb9a8d 5506 sections = bfd_malloc2 (section_count, sizeof (asection *));
252b5132 5507 if (sections == NULL)
b34976b6 5508 return FALSE;
252b5132
RH		 5509
5510 /* Step One: Scan for segment vs section LMA conflicts.
5511 Also add the sections to the section array allocated above.
5512 Also add the sections to the current segment. In the common
5513 case, where the sections have not been moved, this means that
5514 we have completely filled the segment, and there is nothing
5515 more to do. */
252b5132 5516 isec = 0;
72730e0c 5517 matching_lma = 0;
252b5132
RH		 5518 suggested_lma = 0;
5519
bc67d8a6
NC		 5520 for (j = 0, section = ibfd->sections;
5521 section != NULL;
5522 section = section->next)
252b5132 5523 {
caf47ea6 5524 if (INCLUDE_SECTION_IN_SEGMENT (section, segment, bed))
c0f7859b 5525 {
bc67d8a6
NC		 5526 output_section = section->output_section;
5527
5528 sections[j ++] = section;
252b5132
RH		 5529
5530 /* The Solaris native linker always sets p_paddr to 0.
5531 We try to catch that case here, and set it to the
5e8d7549
NC		 5532 correct value. Note - some backends require that
5533 p_paddr be left as zero. */
bc67d8a6 5534 if (segment->p_paddr == 0
4455705d 5535 && segment->p_vaddr != 0
5e8d7549 5536 && (! bed->want_p_paddr_set_to_zero)
252b5132 5537 && isec == 0
bc67d8a6
NC		 5538 && output_section->lma != 0
5539 && (output_section->vma == (segment->p_vaddr
5540 + (map->includes_filehdr
5541 ? iehdr->e_ehsize
5542 : 0)
5543 + (map->includes_phdrs
079e9a2f
AM		 5544 ? (iehdr->e_phnum
5545 * iehdr->e_phentsize)
bc67d8a6
NC		 5546 : 0))))
5547 map->p_paddr = segment->p_vaddr;
252b5132
RH		 5548
5549 /* Match up the physical address of the segment with the
5550 LMA address of the output section. */
bc67d8a6 5551 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5e8d7549
NC		 5552 || IS_COREFILE_NOTE (segment, section)
5553 || (bed->want_p_paddr_set_to_zero &&
5554 IS_CONTAINED_BY_VMA (output_section, segment))
5555 )
252b5132
RH		 5556 {
5557 if (matching_lma == 0)
bc67d8a6 5558 matching_lma = output_section->lma;
252b5132
RH		 5559
5560 /* We assume that if the section fits within the segment
bc67d8a6 5561 then it does not overlap any other section within that
252b5132 5562 segment. */
bc67d8a6 5563 map->sections[isec ++] = output_section;
252b5132
RH		 5564 }
5565 else if (suggested_lma == 0)
bc67d8a6 5566 suggested_lma = output_section->lma;
252b5132
RH		 5567 }
5568 }
5569
bc67d8a6 5570 BFD_ASSERT (j == section_count);
252b5132
RH		 5571
5572 /* Step Two: Adjust the physical address of the current segment,
5573 if necessary. */
bc67d8a6 5574 if (isec == section_count)
252b5132
RH		 5575 {
5576 /* All of the sections fitted within the segment as currently
5577 specified. This is the default case. Add the segment to
5578 the list of built segments and carry on to process the next
5579 program header in the input BFD. */
bc67d8a6 5580 map->count = section_count;
c044fabd
KH		 5581 *pointer_to_map = map;
5582 pointer_to_map = &map->next;
252b5132
RH		 5583
5584 free (sections);
5585 continue;
5586 }
252b5132
RH		 5587 else
5588 {
72730e0c
AM		 5589 if (matching_lma != 0)
5590 {
5591 /* At least one section fits inside the current segment.
5592 Keep it, but modify its physical address to match the
5593 LMA of the first section that fitted. */
bc67d8a6 5594 map->p_paddr = matching_lma;
72730e0c
AM		 5595 }
5596 else
5597 {
5598 /* None of the sections fitted inside the current segment.
5599 Change the current segment's physical address to match
5600 the LMA of the first section. */
bc67d8a6 5601 map->p_paddr = suggested_lma;
72730e0c
AM		 5602 }
5603
bc67d8a6
NC		 5604 /* Offset the segment physical address from the lma
5605 to allow for space taken up by elf headers. */
5606 if (map->includes_filehdr)
5607 map->p_paddr -= iehdr->e_ehsize;
252b5132 5608
bc67d8a6
NC		 5609 if (map->includes_phdrs)
5610 {
5611 map->p_paddr -= iehdr->e_phnum * iehdr->e_phentsize;
5612
5613 /* iehdr->e_phnum is just an estimate of the number
5614 of program headers that we will need. Make a note
5615 here of the number we used and the segment we chose
5616 to hold these headers, so that we can adjust the
5617 offset when we know the correct value. */
5618 phdr_adjust_num = iehdr->e_phnum;
5619 phdr_adjust_seg = map;
5620 }
252b5132
RH		 5621 }
5622
5623 /* Step Three: Loop over the sections again, this time assigning
caf47ea6 5624 those that fit to the current segment and removing them from the
252b5132
RH		 5625 sections array; but making sure not to leave large gaps. Once all
5626 possible sections have been assigned to the current segment it is
5627 added to the list of built segments and if sections still remain
5628 to be assigned, a new segment is constructed before repeating
5629 the loop. */
5630 isec = 0;
5631 do
5632 {
bc67d8a6 5633 map->count = 0;
252b5132
RH		 5634 suggested_lma = 0;
5635
5636 /* Fill the current segment with sections that fit. */
bc67d8a6 5637 for (j = 0; j < section_count; j++)
252b5132 5638 {
bc67d8a6 5639 section = sections[j];
252b5132 5640
bc67d8a6 5641 if (section == NULL)
252b5132
RH		 5642 continue;
5643
bc67d8a6 5644 output_section = section->output_section;
252b5132 5645
bc67d8a6 5646 BFD_ASSERT (output_section != NULL);
c044fabd 5647
bc67d8a6
NC		 5648 if (IS_CONTAINED_BY_LMA (output_section, segment, map->p_paddr)
5649 || IS_COREFILE_NOTE (segment, section))
252b5132 5650 {
bc67d8a6 5651 if (map->count == 0)
252b5132
RH		 5652 {
5653 /* If the first section in a segment does not start at
bc67d8a6
NC		 5654 the beginning of the segment, then something is
5655 wrong. */
5656 if (output_section->lma !=
5657 (map->p_paddr
5658 + (map->includes_filehdr ? iehdr->e_ehsize : 0)
5659 + (map->includes_phdrs
5660 ? iehdr->e_phnum * iehdr->e_phentsize
5661 : 0)))
252b5132
RH		 5662 abort ();
5663 }
5664 else
5665 {
5666 asection * prev_sec;
252b5132 5667
bc67d8a6 5668 prev_sec = map->sections[map->count - 1];
252b5132
RH		 5669
5670 /* If the gap between the end of the previous section
bc67d8a6
NC		 5671 and the start of this section is more than
5672 maxpagesize then we need to start a new segment. */
eea6121a 5673 if ((BFD_ALIGN (prev_sec->lma + prev_sec->size,
079e9a2f 5674 maxpagesize)
caf47ea6 5675 < BFD_ALIGN (output_section->lma, maxpagesize))
eea6121a 5676 || ((prev_sec->lma + prev_sec->size)
079e9a2f 5677 > output_section->lma))
252b5132
RH		 5678 {
5679 if (suggested_lma == 0)
bc67d8a6 5680 suggested_lma = output_section->lma;
252b5132
RH		 5681
5682 continue;
5683 }
5684 }
5685
bc67d8a6 5686 map->sections[map->count++] = output_section;
252b5132
RH		 5687 ++isec;
5688 sections[j] = NULL;
b34976b6 5689 section->segment_mark = TRUE;
252b5132
RH		 5690 }
5691 else if (suggested_lma == 0)
bc67d8a6 5692 suggested_lma = output_section->lma;
252b5132
RH		 5693 }
5694
bc67d8a6 5695 BFD_ASSERT (map->count > 0);
252b5132
RH		 5696
5697 /* Add the current segment to the list of built segments. */
c044fabd
KH		 5698 *pointer_to_map = map;
5699 pointer_to_map = &map->next;
252b5132 5700
bc67d8a6 5701 if (isec < section_count)
252b5132
RH		 5702 {
5703 /* We still have not allocated all of the sections to
5704 segments. Create a new segment here, initialise it
5705 and carry on looping. */
dc810e39
AM		 5706 amt = sizeof (struct elf_segment_map);
5707 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
217aa764 5708 map = bfd_alloc (obfd, amt);
bc67d8a6 5709 if (map == NULL)
5ed6aba4
NC		 5710 {
5711 free (sections);
5712 return FALSE;
5713 }
252b5132
RH		 5714
5715 /* Initialise the fields of the segment map. Set the physical
5716 physical address to the LMA of the first section that has
5717 not yet been assigned. */
bc67d8a6
NC		 5718 map->next = NULL;
5719 map->p_type = segment->p_type;
5720 map->p_flags = segment->p_flags;
5721 map->p_flags_valid = 1;
5722 map->p_paddr = suggested_lma;
5723 map->p_paddr_valid = 1;
5724 map->includes_filehdr = 0;
5725 map->includes_phdrs = 0;
252b5132
RH		 5726 }
5727 }
bc67d8a6 5728 while (isec < section_count);
252b5132
RH		 5729
5730 free (sections);
5731 }
5732
5733 /* The Solaris linker creates program headers in which all the
5734 p_paddr fields are zero. When we try to objcopy or strip such a
5735 file, we get confused. Check for this case, and if we find it
5736 reset the p_paddr_valid fields. */
bc67d8a6
NC		 5737 for (map = map_first; map != NULL; map = map->next)
5738 if (map->p_paddr != 0)
252b5132 5739 break;
bc67d8a6 5740 if (map == NULL)
b5f852ea
NC		 5741 for (map = map_first; map != NULL; map = map->next)
5742 map->p_paddr_valid = 0;
252b5132 5743
bc67d8a6
NC		 5744 elf_tdata (obfd)->segment_map = map_first;
5745
5746 /* If we had to estimate the number of program headers that were
9ad5cbcf 5747 going to be needed, then check our estimate now and adjust
bc67d8a6
NC		 5748 the offset if necessary. */
5749 if (phdr_adjust_seg != NULL)
5750 {
5751 unsigned int count;
c044fabd 5752
bc67d8a6 5753 for (count = 0, map = map_first; map != NULL; map = map->next)
c044fabd 5754 count++;
252b5132 5755
bc67d8a6
NC		 5756 if (count > phdr_adjust_num)
5757 phdr_adjust_seg->p_paddr
5758 -= (count - phdr_adjust_num) * iehdr->e_phentsize;
5759 }
c044fabd 5760
bc67d8a6 5761#undef SEGMENT_END
eecdbe52 5762#undef SECTION_SIZE
bc67d8a6
NC		 5763#undef IS_CONTAINED_BY_VMA
5764#undef IS_CONTAINED_BY_LMA
252b5132 5765#undef IS_COREFILE_NOTE
bc67d8a6 5766#undef IS_SOLARIS_PT_INTERP
9f17e2a6 5767#undef IS_SECTION_IN_INPUT_SEGMENT
bc67d8a6
NC		 5768#undef INCLUDE_SECTION_IN_SEGMENT
5769#undef SEGMENT_AFTER_SEGMENT
5770#undef SEGMENT_OVERLAPS
b34976b6 5771 return TRUE;
252b5132
RH		 5772}
5773
84d1d650
L		 5774/* Copy ELF program header information. */
5775
5776static bfd_boolean
5777copy_elf_program_header (bfd *ibfd, bfd *obfd)
5778{
5779 Elf_Internal_Ehdr *iehdr;
5780 struct elf_segment_map *map;
5781 struct elf_segment_map *map_first;
5782 struct elf_segment_map **pointer_to_map;
5783 Elf_Internal_Phdr *segment;
5784 unsigned int i;
5785 unsigned int num_segments;
5786 bfd_boolean phdr_included = FALSE;
5787
5788 iehdr = elf_elfheader (ibfd);
5789
5790 map_first = NULL;
5791 pointer_to_map = &map_first;
5792
5793 num_segments = elf_elfheader (ibfd)->e_phnum;
5794 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5795 i < num_segments;
5796 i++, segment++)
5797 {
5798 asection *section;
5799 unsigned int section_count;
5800 bfd_size_type amt;
5801 Elf_Internal_Shdr *this_hdr;
5802
5803 /* FIXME: Do we need to copy PT_NULL segment? */
5804 if (segment->p_type == PT_NULL)
5805 continue;
5806
5807 /* Compute how many sections are in this segment. */
5808 for (section = ibfd->sections, section_count = 0;
5809 section != NULL;
5810 section = section->next)
5811 {
5812 this_hdr = &(elf_section_data(section)->this_hdr);
5813 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5814 section_count++;
5815 }
5816
5817 /* Allocate a segment map big enough to contain
5818 all of the sections we have selected. */
5819 amt = sizeof (struct elf_segment_map);
5820 if (section_count != 0)
5821 amt += ((bfd_size_type) section_count - 1) * sizeof (asection *);
41f8ce69 5822 map = bfd_zalloc (obfd, amt);
84d1d650
L		 5823 if (map == NULL)
5824 return FALSE;
5825
5826 /* Initialize the fields of the output segment map with the
5827 input segment. */
5828 map->next = NULL;
5829 map->p_type = segment->p_type;
5830 map->p_flags = segment->p_flags;
5831 map->p_flags_valid = 1;
5832 map->p_paddr = segment->p_paddr;
5833 map->p_paddr_valid = 1;
3f570048
AM		 5834 map->p_align = segment->p_align;
5835 map->p_align_valid = 1;
84d1d650
L		 5836
5837 /* Determine if this segment contains the ELF file header
5838 and if it contains the program headers themselves. */
5839 map->includes_filehdr = (segment->p_offset == 0
5840 && segment->p_filesz >= iehdr->e_ehsize);
5841
5842 map->includes_phdrs = 0;
5843 if (! phdr_included || segment->p_type != PT_LOAD)
5844 {
5845 map->includes_phdrs =
5846 (segment->p_offset <= (bfd_vma) iehdr->e_phoff
5847 && (segment->p_offset + segment->p_filesz
5848 >= ((bfd_vma) iehdr->e_phoff
5849 + iehdr->e_phnum * iehdr->e_phentsize)));
5850
5851 if (segment->p_type == PT_LOAD && map->includes_phdrs)
5852 phdr_included = TRUE;
5853 }
5854
5855 if (section_count != 0)
5856 {
5857 unsigned int isec = 0;
5858
5859 for (section = ibfd->sections;
5860 section != NULL;
5861 section = section->next)
5862 {
5863 this_hdr = &(elf_section_data(section)->this_hdr);
5864 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5865 map->sections[isec++] = section->output_section;
5866 }
5867 }
5868
5869 map->count = section_count;
5870 *pointer_to_map = map;
5871 pointer_to_map = &map->next;
5872 }
5873
5874 elf_tdata (obfd)->segment_map = map_first;
5875 return TRUE;
5876}
5877
5878/* Copy private BFD data. This copies or rewrites ELF program header
5879 information. */
5880
5881static bfd_boolean
5882copy_private_bfd_data (bfd *ibfd, bfd *obfd)
5883{
84d1d650
L		 5884 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
5885 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
5886 return TRUE;
5887
5888 if (elf_tdata (ibfd)->phdr == NULL)
5889 return TRUE;
5890
5891 if (ibfd->xvec == obfd->xvec)
5892 {
5893 /* Check if any sections in the input BFD covered by ELF program
5894 header are changed. */
d55ce4e2 5895 Elf_Internal_Phdr *segment;
84d1d650
L		 5896 asection *section, *osec;
5897 unsigned int i, num_segments;
5898 Elf_Internal_Shdr *this_hdr;
5899
5900 /* Initialize the segment mark field. */
5901 for (section = obfd->sections; section != NULL;
5902 section = section->next)
5903 section->segment_mark = FALSE;
5904
5905 num_segments = elf_elfheader (ibfd)->e_phnum;
5906 for (i = 0, segment = elf_tdata (ibfd)->phdr;
5907 i < num_segments;
5908 i++, segment++)
5909 {
5910 for (section = ibfd->sections;
5911 section != NULL; section = section->next)
5912 {
5913 /* We mark the output section so that we know it comes
5914 from the input BFD. */
5915 osec = section->output_section;
5916 if (osec)
5917 osec->segment_mark = TRUE;
5918
5919 /* Check if this section is covered by the segment. */
5920 this_hdr = &(elf_section_data(section)->this_hdr);
5921 if (ELF_IS_SECTION_IN_SEGMENT_FILE (this_hdr, segment))
5922 {
5923 /* FIXME: Check if its output section is changed or
5924 removed. What else do we need to check? */
5925 if (osec == NULL
5926 || section->flags != osec->flags
5927 || section->lma != osec->lma
5928 || section->vma != osec->vma
5929 || section->size != osec->size
5930 || section->rawsize != osec->rawsize
5931 || section->alignment_power != osec->alignment_power)
5932 goto rewrite;
5933 }
5934 }
5935 }
5936
5937 /* Check to see if any output section doesn't come from the
5938 input BFD. */
5939 for (section = obfd->sections; section != NULL;
5940 section = section->next)
5941 {
5942 if (section->segment_mark == FALSE)
5943 goto rewrite;
5944 else
5945 section->segment_mark = FALSE;
5946 }
5947
5948 return copy_elf_program_header (ibfd, obfd);
5949 }
5950
5951rewrite:
5952 return rewrite_elf_program_header (ibfd, obfd);
5953}
5954
ccd2ec6a
L		 5955/* Initialize private output section information from input section. */
5956
5957bfd_boolean
5958_bfd_elf_init_private_section_data (bfd *ibfd,
5959 asection *isec,
5960 bfd *obfd,
5961 asection *osec,
5962 struct bfd_link_info *link_info)
5963
5964{
5965 Elf_Internal_Shdr *ihdr, *ohdr;
5966 bfd_boolean need_group = link_info == NULL || link_info->relocatable;
5967
5968 if (ibfd->xvec->flavour != bfd_target_elf_flavour
5969 || obfd->xvec->flavour != bfd_target_elf_flavour)
5970 return TRUE;
5971
e843e0f8 5972 /* Don't copy the output ELF section type from input if the
d3fd4074 5973 output BFD section flags have been set to something different.
e843e0f8
L		 5974 elf_fake_sections will set ELF section type based on BFD
5975 section flags. */
d270463e
L		 5976 if (osec->flags == isec->flags || !osec->flags)
5977 {
5978 BFD_ASSERT (osec->flags == isec->flags
5979 || (!osec->flags
5980 && elf_section_type (osec) == SHT_NULL));
5981 elf_section_type (osec) = elf_section_type (isec);
5982 }
5983
5984 /* FIXME: Is this correct for all OS/PROC specific flags? */
5985 elf_section_flags (osec) |= (elf_section_flags (isec)
5986 & (SHF_MASKOS | SHF_MASKPROC));
ccd2ec6a
L		 5987
5988 /* Set things up for objcopy and relocatable link. The output
5989 SHT_GROUP section will have its elf_next_in_group pointing back
5990 to the input group members. Ignore linker created group section.
5991 See elfNN_ia64_object_p in elfxx-ia64.c. */
ccd2ec6a
L		 5992 if (need_group)
5993 {
5994 if (elf_sec_group (isec) == NULL
5995 || (elf_sec_group (isec)->flags & SEC_LINKER_CREATED) == 0)
5996 {
5997 if (elf_section_flags (isec) & SHF_GROUP)
5998 elf_section_flags (osec) |= SHF_GROUP;
5999 elf_next_in_group (osec) = elf_next_in_group (isec);
6000 elf_group_name (osec) = elf_group_name (isec);
6001 }
6002 }
6003
6004 ihdr = &elf_section_data (isec)->this_hdr;
6005
6006 /* We need to handle elf_linked_to_section for SHF_LINK_ORDER. We
6007 don't use the output section of the linked-to section since it
6008 may be NULL at this point. */
6009 if ((ihdr->sh_flags & SHF_LINK_ORDER) != 0)
6010 {
6011 ohdr = &elf_section_data (osec)->this_hdr;
6012 ohdr->sh_flags |= SHF_LINK_ORDER;
6013 elf_linked_to_section (osec) = elf_linked_to_section (isec);
6014 }
6015
6016 osec->use_rela_p = isec->use_rela_p;
6017
6018 return TRUE;
6019}
6020
252b5132
RH		 6021/* Copy private section information. This copies over the entsize
6022 field, and sometimes the info field. */
6023
b34976b6 6024bfd_boolean
217aa764
AM		 6025_bfd_elf_copy_private_section_data (bfd *ibfd,
6026 asection *isec,
6027 bfd *obfd,
6028 asection *osec)
252b5132
RH		 6029{
6030 Elf_Internal_Shdr *ihdr, *ohdr;
6031
6032 if (ibfd->xvec->flavour != bfd_target_elf_flavour
6033 || obfd->xvec->flavour != bfd_target_elf_flavour)
b34976b6 6034 return TRUE;
252b5132 6035
252b5132
RH		 6036 ihdr = &elf_section_data (isec)->this_hdr;
6037 ohdr = &elf_section_data (osec)->this_hdr;
6038
6039 ohdr->sh_entsize = ihdr->sh_entsize;
6040
6041 if (ihdr->sh_type == SHT_SYMTAB
6042 || ihdr->sh_type == SHT_DYNSYM
6043 || ihdr->sh_type == SHT_GNU_verneed
6044 || ihdr->sh_type == SHT_GNU_verdef)
6045 ohdr->sh_info = ihdr->sh_info;
6046
ccd2ec6a
L		 6047 return _bfd_elf_init_private_section_data (ibfd, isec, obfd, osec,
6048 NULL);
252b5132
RH		 6049}
6050
80fccad2
BW		 6051/* Copy private header information. */
6052
6053bfd_boolean
6054_bfd_elf_copy_private_header_data (bfd *ibfd, bfd *obfd)
6055{
30288845
AM		 6056 asection *isec;
6057
80fccad2
BW		 6058 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6059 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6060 return TRUE;
6061
6062 /* Copy over private BFD data if it has not already been copied.
6063 This must be done here, rather than in the copy_private_bfd_data
6064 entry point, because the latter is called after the section
6065 contents have been set, which means that the program headers have
6066 already been worked out. */
6067 if (elf_tdata (obfd)->segment_map == NULL && elf_tdata (ibfd)->phdr != NULL)
6068 {
6069 if (! copy_private_bfd_data (ibfd, obfd))
6070 return FALSE;
6071 }
6072
30288845
AM		 6073 /* _bfd_elf_copy_private_section_data copied over the SHF_GROUP flag
6074 but this might be wrong if we deleted the group section. */
6075 for (isec = ibfd->sections; isec != NULL; isec = isec->next)
6076 if (elf_section_type (isec) == SHT_GROUP
6077 && isec->output_section == NULL)
6078 {
6079 asection *first = elf_next_in_group (isec);
6080 asection *s = first;
6081 while (s != NULL)
6082 {
6083 if (s->output_section != NULL)
6084 {
6085 elf_section_flags (s->output_section) &= ~SHF_GROUP;
6086 elf_group_name (s->output_section) = NULL;
6087 }
6088 s = elf_next_in_group (s);
6089 if (s == first)
6090 break;
6091 }
6092 }
6093
80fccad2
BW		 6094 return TRUE;
6095}
6096
252b5132
RH		 6097/* Copy private symbol information. If this symbol is in a section
6098 which we did not map into a BFD section, try to map the section
6099 index correctly. We use special macro definitions for the mapped
6100 section indices; these definitions are interpreted by the
6101 swap_out_syms function. */
6102
9ad5cbcf
AM		 6103#define MAP_ONESYMTAB (SHN_HIOS + 1)
6104#define MAP_DYNSYMTAB (SHN_HIOS + 2)
6105#define MAP_STRTAB (SHN_HIOS + 3)
6106#define MAP_SHSTRTAB (SHN_HIOS + 4)
6107#define MAP_SYM_SHNDX (SHN_HIOS + 5)
252b5132 6108
b34976b6 6109bfd_boolean
217aa764
AM		 6110_bfd_elf_copy_private_symbol_data (bfd *ibfd,
6111 asymbol *isymarg,
6112 bfd *obfd,
6113 asymbol *osymarg)
252b5132
RH		 6114{
6115 elf_symbol_type *isym, *osym;
6116
6117 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6118 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
b34976b6 6119 return TRUE;
252b5132
RH		 6120
6121 isym = elf_symbol_from (ibfd, isymarg);
6122 osym = elf_symbol_from (obfd, osymarg);
6123
6124 if (isym != NULL
6125 && osym != NULL
6126 && bfd_is_abs_section (isym->symbol.section))
6127 {
6128 unsigned int shndx;
6129
6130 shndx = isym->internal_elf_sym.st_shndx;
6131 if (shndx == elf_onesymtab (ibfd))
6132 shndx = MAP_ONESYMTAB;
6133 else if (shndx == elf_dynsymtab (ibfd))
6134 shndx = MAP_DYNSYMTAB;
6135 else if (shndx == elf_tdata (ibfd)->strtab_section)
6136 shndx = MAP_STRTAB;
6137 else if (shndx == elf_tdata (ibfd)->shstrtab_section)
6138 shndx = MAP_SHSTRTAB;
9ad5cbcf
AM		 6139 else if (shndx == elf_tdata (ibfd)->symtab_shndx_section)
6140 shndx = MAP_SYM_SHNDX;
252b5132
RH		 6141 osym->internal_elf_sym.st_shndx = shndx;
6142 }
6143
b34976b6 6144 return TRUE;
252b5132
RH		 6145}
6146
6147/* Swap out the symbols. */
6148
b34976b6 6149static bfd_boolean
217aa764
AM		 6150swap_out_syms (bfd *abfd,
6151 struct bfd_strtab_hash **sttp,
6152 int relocatable_p)
252b5132 6153{
9c5bfbb7 6154 const struct elf_backend_data *bed;
079e9a2f
AM		 6155 int symcount;
6156 asymbol **syms;
6157 struct bfd_strtab_hash *stt;
6158 Elf_Internal_Shdr *symtab_hdr;
9ad5cbcf 6159 Elf_Internal_Shdr *symtab_shndx_hdr;
079e9a2f 6160 Elf_Internal_Shdr *symstrtab_hdr;
f075ee0c
AM		 6161 bfd_byte *outbound_syms;
6162 bfd_byte *outbound_shndx;
079e9a2f
AM		 6163 int idx;
6164 bfd_size_type amt;
174fd7f9 6165 bfd_boolean name_local_sections;
252b5132
RH		 6166
6167 if (!elf_map_symbols (abfd))
b34976b6 6168 return FALSE;
252b5132 6169
c044fabd 6170 /* Dump out the symtabs. */
079e9a2f
AM		 6171 stt = _bfd_elf_stringtab_init ();
6172 if (stt == NULL)
b34976b6 6173 return FALSE;
252b5132 6174
079e9a2f
AM		 6175 bed = get_elf_backend_data (abfd);
6176 symcount = bfd_get_symcount (abfd);
6177 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6178 symtab_hdr->sh_type = SHT_SYMTAB;
6179 symtab_hdr->sh_entsize = bed->s->sizeof_sym;
6180 symtab_hdr->sh_size = symtab_hdr->sh_entsize * (symcount + 1);
6181 symtab_hdr->sh_info = elf_num_locals (abfd) + 1;
45d6a902 6182 symtab_hdr->sh_addralign = 1 << bed->s->log_file_align;
079e9a2f
AM		 6183
6184 symstrtab_hdr = &elf_tdata (abfd)->strtab_hdr;
6185 symstrtab_hdr->sh_type = SHT_STRTAB;
6186
d0fb9a8d 6187 outbound_syms = bfd_alloc2 (abfd, 1 + symcount, bed->s->sizeof_sym);
079e9a2f 6188 if (outbound_syms == NULL)
5ed6aba4
NC		 6189 {
6190 _bfd_stringtab_free (stt);
6191 return FALSE;
6192 }
217aa764 6193 symtab_hdr->contents = outbound_syms;
252b5132 6194
9ad5cbcf
AM		 6195 outbound_shndx = NULL;
6196 symtab_shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
6197 if (symtab_shndx_hdr->sh_name != 0)
6198 {
6199 amt = (bfd_size_type) (1 + symcount) * sizeof (Elf_External_Sym_Shndx);
d0fb9a8d
JJ		 6200 outbound_shndx = bfd_zalloc2 (abfd, 1 + symcount,
6201 sizeof (Elf_External_Sym_Shndx));
9ad5cbcf 6202 if (outbound_shndx == NULL)
5ed6aba4
NC		 6203 {
6204 _bfd_stringtab_free (stt);
6205 return FALSE;
6206 }
6207
9ad5cbcf
AM		 6208 symtab_shndx_hdr->contents = outbound_shndx;
6209 symtab_shndx_hdr->sh_type = SHT_SYMTAB_SHNDX;
6210 symtab_shndx_hdr->sh_size = amt;
6211 symtab_shndx_hdr->sh_addralign = sizeof (Elf_External_Sym_Shndx);
6212 symtab_shndx_hdr->sh_entsize = sizeof (Elf_External_Sym_Shndx);
6213 }
6214
589e6347 6215 /* Now generate the data (for "contents"). */
079e9a2f
AM		 6216 {
6217 /* Fill in zeroth symbol and swap it out. */
6218 Elf_Internal_Sym sym;
6219 sym.st_name = 0;
6220 sym.st_value = 0;
6221 sym.st_size = 0;
6222 sym.st_info = 0;
6223 sym.st_other = 0;
6224 sym.st_shndx = SHN_UNDEF;
9ad5cbcf 6225 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6226 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 6227 if (outbound_shndx != NULL)
6228 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6229 }
252b5132 6230
174fd7f9
RS		 6231 name_local_sections
6232 = (bed->elf_backend_name_local_section_symbols
6233 && bed->elf_backend_name_local_section_symbols (abfd));
6234
079e9a2f
AM		 6235 syms = bfd_get_outsymbols (abfd);
6236 for (idx = 0; idx < symcount; idx++)
252b5132 6237 {
252b5132 6238 Elf_Internal_Sym sym;
079e9a2f
AM		 6239 bfd_vma value = syms[idx]->value;
6240 elf_symbol_type *type_ptr;
6241 flagword flags = syms[idx]->flags;
6242 int type;
252b5132 6243
174fd7f9
RS		 6244 if (!name_local_sections
6245 && (flags & (BSF_SECTION_SYM | BSF_GLOBAL)) == BSF_SECTION_SYM)
079e9a2f
AM		 6246 {
6247 /* Local section symbols have no name. */
6248 sym.st_name = 0;
6249 }
6250 else
6251 {
6252 sym.st_name = (unsigned long) _bfd_stringtab_add (stt,
6253 syms[idx]->name,
b34976b6 6254 TRUE, FALSE);
079e9a2f 6255 if (sym.st_name == (unsigned long) -1)
5ed6aba4
NC		 6256 {
6257 _bfd_stringtab_free (stt);
6258 return FALSE;
6259 }
079e9a2f 6260 }
252b5132 6261
079e9a2f 6262 type_ptr = elf_symbol_from (abfd, syms[idx]);
252b5132 6263
079e9a2f
AM		 6264 if ((flags & BSF_SECTION_SYM) == 0
6265 && bfd_is_com_section (syms[idx]->section))
6266 {
6267 /* ELF common symbols put the alignment into the `value' field,
6268 and the size into the `size' field. This is backwards from
6269 how BFD handles it, so reverse it here. */
6270 sym.st_size = value;
6271 if (type_ptr == NULL
6272 || type_ptr->internal_elf_sym.st_value == 0)
6273 sym.st_value = value >= 16 ? 16 : (1 << bfd_log2 (value));
6274 else
6275 sym.st_value = type_ptr->internal_elf_sym.st_value;
6276 sym.st_shndx = _bfd_elf_section_from_bfd_section
6277 (abfd, syms[idx]->section);
6278 }
6279 else
6280 {
6281 asection *sec = syms[idx]->section;
6282 int shndx;
252b5132 6283
079e9a2f
AM		 6284 if (sec->output_section)
6285 {
6286 value += sec->output_offset;
6287 sec = sec->output_section;
6288 }
589e6347 6289
079e9a2f
AM		 6290 /* Don't add in the section vma for relocatable output. */
6291 if (! relocatable_p)
6292 value += sec->vma;
6293 sym.st_value = value;
6294 sym.st_size = type_ptr ? type_ptr->internal_elf_sym.st_size : 0;
6295
6296 if (bfd_is_abs_section (sec)
6297 && type_ptr != NULL
6298 && type_ptr->internal_elf_sym.st_shndx != 0)
6299 {
6300 /* This symbol is in a real ELF section which we did
6301 not create as a BFD section. Undo the mapping done
6302 by copy_private_symbol_data. */
6303 shndx = type_ptr->internal_elf_sym.st_shndx;
6304 switch (shndx)
6305 {
6306 case MAP_ONESYMTAB:
6307 shndx = elf_onesymtab (abfd);
6308 break;
6309 case MAP_DYNSYMTAB:
6310 shndx = elf_dynsymtab (abfd);
6311 break;
6312 case MAP_STRTAB:
6313 shndx = elf_tdata (abfd)->strtab_section;
6314 break;
6315 case MAP_SHSTRTAB:
6316 shndx = elf_tdata (abfd)->shstrtab_section;
6317 break;
9ad5cbcf
AM		 6318 case MAP_SYM_SHNDX:
6319 shndx = elf_tdata (abfd)->symtab_shndx_section;
6320 break;
079e9a2f
AM		 6321 default:
6322 break;
6323 }
6324 }
6325 else
6326 {
6327 shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
252b5132 6328
079e9a2f
AM		 6329 if (shndx == -1)
6330 {
6331 asection *sec2;
6332
6333 /* Writing this would be a hell of a lot easier if
6334 we had some decent documentation on bfd, and
6335 knew what to expect of the library, and what to
6336 demand of applications. For example, it
6337 appears that `objcopy' might not set the
6338 section of a symbol to be a section that is
6339 actually in the output file. */
6340 sec2 = bfd_get_section_by_name (abfd, sec->name);
589e6347
NC		 6341 if (sec2 == NULL)
6342 {
6343 _bfd_error_handler (_("\
6344Unable to find equivalent output section for symbol '%s' from section '%s'"),
6345 syms[idx]->name ? syms[idx]->name : "<Local sym>",
6346 sec->name);
811072d8 6347 bfd_set_error (bfd_error_invalid_operation);
5ed6aba4 6348 _bfd_stringtab_free (stt);
589e6347
NC		 6349 return FALSE;
6350 }
811072d8 6351
079e9a2f
AM		 6352 shndx = _bfd_elf_section_from_bfd_section (abfd, sec2);
6353 BFD_ASSERT (shndx != -1);
6354 }
6355 }
252b5132 6356
079e9a2f
AM		 6357 sym.st_shndx = shndx;
6358 }
252b5132 6359
13ae64f3
JJ		 6360 if ((flags & BSF_THREAD_LOCAL) != 0)
6361 type = STT_TLS;
6362 else if ((flags & BSF_FUNCTION) != 0)
079e9a2f
AM		 6363 type = STT_FUNC;
6364 else if ((flags & BSF_OBJECT) != 0)
6365 type = STT_OBJECT;
6366 else
6367 type = STT_NOTYPE;
252b5132 6368
13ae64f3
JJ		 6369 if (syms[idx]->section->flags & SEC_THREAD_LOCAL)
6370 type = STT_TLS;
6371
589e6347 6372 /* Processor-specific types. */
079e9a2f
AM		 6373 if (type_ptr != NULL
6374 && bed->elf_backend_get_symbol_type)
6375 type = ((*bed->elf_backend_get_symbol_type)
6376 (&type_ptr->internal_elf_sym, type));
252b5132 6377
079e9a2f
AM		 6378 if (flags & BSF_SECTION_SYM)
6379 {
6380 if (flags & BSF_GLOBAL)
6381 sym.st_info = ELF_ST_INFO (STB_GLOBAL, STT_SECTION);
6382 else
6383 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_SECTION);
6384 }
6385 else if (bfd_is_com_section (syms[idx]->section))
6386 sym.st_info = ELF_ST_INFO (STB_GLOBAL, type);
6387 else if (bfd_is_und_section (syms[idx]->section))
6388 sym.st_info = ELF_ST_INFO (((flags & BSF_WEAK)
6389 ? STB_WEAK
6390 : STB_GLOBAL),
6391 type);
6392 else if (flags & BSF_FILE)
6393 sym.st_info = ELF_ST_INFO (STB_LOCAL, STT_FILE);
6394 else
6395 {
6396 int bind = STB_LOCAL;
252b5132 6397
079e9a2f
AM		 6398 if (flags & BSF_LOCAL)
6399 bind = STB_LOCAL;
6400 else if (flags & BSF_WEAK)
6401 bind = STB_WEAK;
6402 else if (flags & BSF_GLOBAL)
6403 bind = STB_GLOBAL;
252b5132 6404
079e9a2f
AM		 6405 sym.st_info = ELF_ST_INFO (bind, type);
6406 }
252b5132 6407
079e9a2f
AM		 6408 if (type_ptr != NULL)
6409 sym.st_other = type_ptr->internal_elf_sym.st_other;
6410 else
6411 sym.st_other = 0;
252b5132 6412
9ad5cbcf 6413 bed->s->swap_symbol_out (abfd, &sym, outbound_syms, outbound_shndx);
079e9a2f 6414 outbound_syms += bed->s->sizeof_sym;
9ad5cbcf
AM		 6415 if (outbound_shndx != NULL)
6416 outbound_shndx += sizeof (Elf_External_Sym_Shndx);
079e9a2f 6417 }
252b5132 6418
079e9a2f
AM		 6419 *sttp = stt;
6420 symstrtab_hdr->sh_size = _bfd_stringtab_size (stt);
6421 symstrtab_hdr->sh_type = SHT_STRTAB;
252b5132 6422
079e9a2f
AM		 6423 symstrtab_hdr->sh_flags = 0;
6424 symstrtab_hdr->sh_addr = 0;
6425 symstrtab_hdr->sh_entsize = 0;
6426 symstrtab_hdr->sh_link = 0;
6427 symstrtab_hdr->sh_info = 0;
6428 symstrtab_hdr->sh_addralign = 1;
252b5132 6429
b34976b6 6430 return TRUE;
252b5132
RH		 6431}
6432
6433/* Return the number of bytes required to hold the symtab vector.
6434
6435 Note that we base it on the count plus 1, since we will null terminate
6436 the vector allocated based on this size. However, the ELF symbol table
6437 always has a dummy entry as symbol #0, so it ends up even. */
6438
6439long
217aa764 6440_bfd_elf_get_symtab_upper_bound (bfd *abfd)
252b5132
RH		 6441{
6442 long symcount;
6443 long symtab_size;
6444 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->symtab_hdr;
6445
6446 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM		 6447 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6448 if (symcount > 0)
6449 symtab_size -= sizeof (asymbol *);
252b5132
RH		 6450
6451 return symtab_size;
6452}
6453
6454long
217aa764 6455_bfd_elf_get_dynamic_symtab_upper_bound (bfd *abfd)
252b5132
RH		 6456{
6457 long symcount;
6458 long symtab_size;
6459 Elf_Internal_Shdr *hdr = &elf_tdata (abfd)->dynsymtab_hdr;
6460
6461 if (elf_dynsymtab (abfd) == 0)
6462 {
6463 bfd_set_error (bfd_error_invalid_operation);
6464 return -1;
6465 }
6466
6467 symcount = hdr->sh_size / get_elf_backend_data (abfd)->s->sizeof_sym;
b99d1833
AM		 6468 symtab_size = (symcount + 1) * (sizeof (asymbol *));
6469 if (symcount > 0)
6470 symtab_size -= sizeof (asymbol *);
252b5132
RH		 6471
6472 return symtab_size;
6473}
6474
6475long
217aa764
AM		 6476_bfd_elf_get_reloc_upper_bound (bfd *abfd ATTRIBUTE_UNUSED,
6477 sec_ptr asect)
252b5132
RH		 6478{
6479 return (asect->reloc_count + 1) * sizeof (arelent *);
6480}
6481
6482/* Canonicalize the relocs. */
6483
6484long
217aa764
AM		 6485_bfd_elf_canonicalize_reloc (bfd *abfd,
6486 sec_ptr section,
6487 arelent **relptr,
6488 asymbol **symbols)
252b5132
RH		 6489{
6490 arelent *tblptr;
6491 unsigned int i;
9c5bfbb7 6492 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
252b5132 6493
b34976b6 6494 if (! bed->s->slurp_reloc_table (abfd, section, symbols, FALSE))
252b5132
RH		 6495 return -1;
6496
6497 tblptr = section->relocation;
6498 for (i = 0; i < section->reloc_count; i++)
6499 *relptr++ = tblptr++;
6500
6501 *relptr = NULL;
6502
6503 return section->reloc_count;
6504}
6505
6506long
6cee3f79 6507_bfd_elf_canonicalize_symtab (bfd *abfd, asymbol **allocation)
252b5132 6508{
9c5bfbb7 6509 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 6510 long symcount = bed->s->slurp_symbol_table (abfd, allocation, FALSE);
252b5132
RH		 6511
6512 if (symcount >= 0)
6513 bfd_get_symcount (abfd) = symcount;
6514 return symcount;
6515}
6516
6517long
217aa764
AM		 6518_bfd_elf_canonicalize_dynamic_symtab (bfd *abfd,
6519 asymbol **allocation)
252b5132 6520{
9c5bfbb7 6521 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
217aa764 6522 long symcount = bed->s->slurp_symbol_table (abfd, allocation, TRUE);
1f70368c
DJ		 6523
6524 if (symcount >= 0)
6525 bfd_get_dynamic_symcount (abfd) = symcount;
6526 return symcount;
252b5132
RH		 6527}
6528
8615f3f2
AM		 6529/* Return the size required for the dynamic reloc entries. Any loadable
6530 section that was actually installed in the BFD, and has type SHT_REL
6531 or SHT_RELA, and uses the dynamic symbol table, is considered to be a
6532 dynamic reloc section. */
252b5132
RH		 6533
6534long
217aa764 6535_bfd_elf_get_dynamic_reloc_upper_bound (bfd *abfd)
252b5132
RH		 6536{
6537 long ret;
6538 asection *s;
6539
6540 if (elf_dynsymtab (abfd) == 0)
6541 {
6542 bfd_set_error (bfd_error_invalid_operation);
6543 return -1;
6544 }
6545
6546 ret = sizeof (arelent *);
6547 for (s = abfd->sections; s != NULL; s = s->next)
8615f3f2
AM		 6548 if ((s->flags & SEC_LOAD) != 0
6549 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH		 6550 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6551 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
eea6121a 6552 ret += ((s->size / elf_section_data (s)->this_hdr.sh_entsize)
252b5132
RH		 6553 * sizeof (arelent *));
6554
6555 return ret;
6556}
6557
8615f3f2
AM		 6558/* Canonicalize the dynamic relocation entries. Note that we return the
6559 dynamic relocations as a single block, although they are actually
6560 associated with particular sections; the interface, which was
6561 designed for SunOS style shared libraries, expects that there is only
6562 one set of dynamic relocs. Any loadable section that was actually
6563 installed in the BFD, and has type SHT_REL or SHT_RELA, and uses the
6564 dynamic symbol table, is considered to be a dynamic reloc section. */
252b5132
RH		 6565
6566long
217aa764
AM		 6567_bfd_elf_canonicalize_dynamic_reloc (bfd *abfd,
6568 arelent **storage,
6569 asymbol **syms)
252b5132 6570{
217aa764 6571 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
252b5132
RH		 6572 asection *s;
6573 long ret;
6574
6575 if (elf_dynsymtab (abfd) == 0)
6576 {
6577 bfd_set_error (bfd_error_invalid_operation);
6578 return -1;
6579 }
6580
6581 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
6582 ret = 0;
6583 for (s = abfd->sections; s != NULL; s = s->next)
6584 {
8615f3f2
AM		 6585 if ((s->flags & SEC_LOAD) != 0
6586 && elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd)
252b5132
RH		 6587 && (elf_section_data (s)->this_hdr.sh_type == SHT_REL
6588 || elf_section_data (s)->this_hdr.sh_type == SHT_RELA))
6589 {
6590 arelent *p;
6591 long count, i;
6592
b34976b6 6593 if (! (*slurp_relocs) (abfd, s, syms, TRUE))
252b5132 6594 return -1;
eea6121a 6595 count = s->size / elf_section_data (s)->this_hdr.sh_entsize;
252b5132
RH		 6596 p = s->relocation;
6597 for (i = 0; i < count; i++)
6598 *storage++ = p++;
6599 ret += count;
6600 }
6601 }
6602
6603 *storage = NULL;
6604
6605 return ret;
6606}
6607\f
6608/* Read in the version information. */
6609
b34976b6 6610bfd_boolean
fc0e6df6 6611_bfd_elf_slurp_version_tables (bfd *abfd, bfd_boolean default_imported_symver)
252b5132
RH		 6612{
6613 bfd_byte *contents = NULL;
fc0e6df6
PB		 6614 unsigned int freeidx = 0;
6615
6616 if (elf_dynverref (abfd) != 0)
6617 {
6618 Elf_Internal_Shdr *hdr;
6619 Elf_External_Verneed *everneed;
6620 Elf_Internal_Verneed *iverneed;
6621 unsigned int i;
d0fb9a8d 6622 bfd_byte *contents_end;
fc0e6df6
PB		 6623
6624 hdr = &elf_tdata (abfd)->dynverref_hdr;
6625
d0fb9a8d
JJ		 6626 elf_tdata (abfd)->verref = bfd_zalloc2 (abfd, hdr->sh_info,
6627 sizeof (Elf_Internal_Verneed));
fc0e6df6
PB		 6628 if (elf_tdata (abfd)->verref == NULL)
6629 goto error_return;
6630
6631 elf_tdata (abfd)->cverrefs = hdr->sh_info;
6632
6633 contents = bfd_malloc (hdr->sh_size);
6634 if (contents == NULL)
d0fb9a8d
JJ		 6635 {
6636error_return_verref:
6637 elf_tdata (abfd)->verref = NULL;
6638 elf_tdata (abfd)->cverrefs = 0;
6639 goto error_return;
6640 }
fc0e6df6
PB		 6641 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
6642 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
d0fb9a8d 6643 goto error_return_verref;
fc0e6df6 6644
d0fb9a8d
JJ		 6645 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verneed))
6646 goto error_return_verref;
6647
6648 BFD_ASSERT (sizeof (Elf_External_Verneed)
6649 == sizeof (Elf_External_Vernaux));
6650 contents_end = contents + hdr->sh_size - sizeof (Elf_External_Verneed);
fc0e6df6
PB		 6651 everneed = (Elf_External_Verneed *) contents;
6652 iverneed = elf_tdata (abfd)->verref;
6653 for (i = 0; i < hdr->sh_info; i++, iverneed++)
6654 {
6655 Elf_External_Vernaux *evernaux;
6656 Elf_Internal_Vernaux *ivernaux;
6657 unsigned int j;
6658
6659 _bfd_elf_swap_verneed_in (abfd, everneed, iverneed);
6660
6661 iverneed->vn_bfd = abfd;
6662
6663 iverneed->vn_filename =
6664 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6665 iverneed->vn_file);
6666 if (iverneed->vn_filename == NULL)
d0fb9a8d 6667 goto error_return_verref;
fc0e6df6 6668
d0fb9a8d
JJ		 6669 if (iverneed->vn_cnt == 0)
6670 iverneed->vn_auxptr = NULL;
6671 else
6672 {
6673 iverneed->vn_auxptr = bfd_alloc2 (abfd, iverneed->vn_cnt,
6674 sizeof (Elf_Internal_Vernaux));
6675 if (iverneed->vn_auxptr == NULL)
6676 goto error_return_verref;
6677 }
6678
6679 if (iverneed->vn_aux
6680 > (size_t) (contents_end - (bfd_byte *) everneed))
6681 goto error_return_verref;
fc0e6df6
PB		 6682
6683 evernaux = ((Elf_External_Vernaux *)
6684 ((bfd_byte *) everneed + iverneed->vn_aux));
6685 ivernaux = iverneed->vn_auxptr;
6686 for (j = 0; j < iverneed->vn_cnt; j++, ivernaux++)
6687 {
6688 _bfd_elf_swap_vernaux_in (abfd, evernaux, ivernaux);
6689
6690 ivernaux->vna_nodename =
6691 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6692 ivernaux->vna_name);
6693 if (ivernaux->vna_nodename == NULL)
d0fb9a8d 6694 goto error_return_verref;
fc0e6df6
PB		 6695
6696 if (j + 1 < iverneed->vn_cnt)
6697 ivernaux->vna_nextptr = ivernaux + 1;
6698 else
6699 ivernaux->vna_nextptr = NULL;
6700
d0fb9a8d
JJ		 6701 if (ivernaux->vna_next
6702 > (size_t) (contents_end - (bfd_byte *) evernaux))
6703 goto error_return_verref;
6704
fc0e6df6
PB		 6705 evernaux = ((Elf_External_Vernaux *)
6706 ((bfd_byte *) evernaux + ivernaux->vna_next));
6707
6708 if (ivernaux->vna_other > freeidx)
6709 freeidx = ivernaux->vna_other;
6710 }
6711
6712 if (i + 1 < hdr->sh_info)
6713 iverneed->vn_nextref = iverneed + 1;
6714 else
6715 iverneed->vn_nextref = NULL;
6716
d0fb9a8d
JJ		 6717 if (iverneed->vn_next
6718 > (size_t) (contents_end - (bfd_byte *) everneed))
6719 goto error_return_verref;
6720
fc0e6df6
PB		 6721 everneed = ((Elf_External_Verneed *)
6722 ((bfd_byte *) everneed + iverneed->vn_next));
6723 }
6724
6725 free (contents);
6726 contents = NULL;
6727 }
252b5132
RH		 6728
6729 if (elf_dynverdef (abfd) != 0)
6730 {
6731 Elf_Internal_Shdr *hdr;
6732 Elf_External_Verdef *everdef;
6733 Elf_Internal_Verdef *iverdef;
f631889e
UD		 6734 Elf_Internal_Verdef *iverdefarr;
6735 Elf_Internal_Verdef iverdefmem;
252b5132 6736 unsigned int i;
062e2358 6737 unsigned int maxidx;
d0fb9a8d 6738 bfd_byte *contents_end_def, *contents_end_aux;
252b5132
RH		 6739
6740 hdr = &elf_tdata (abfd)->dynverdef_hdr;
6741
217aa764 6742 contents = bfd_malloc (hdr->sh_size);
252b5132
RH		 6743 if (contents == NULL)
6744 goto error_return;
6745 if (bfd_seek (abfd, hdr->sh_offset, SEEK_SET) != 0
217aa764 6746 || bfd_bread (contents, hdr->sh_size, abfd) != hdr->sh_size)
252b5132
RH		 6747 goto error_return;
6748
d0fb9a8d
JJ		 6749 if (hdr->sh_info && hdr->sh_size < sizeof (Elf_External_Verdef))
6750 goto error_return;
6751
6752 BFD_ASSERT (sizeof (Elf_External_Verdef)
6753 >= sizeof (Elf_External_Verdaux));
6754 contents_end_def = contents + hdr->sh_size
6755 - sizeof (Elf_External_Verdef);
6756 contents_end_aux = contents + hdr->sh_size
6757 - sizeof (Elf_External_Verdaux);
6758
f631889e
UD		 6759 /* We know the number of entries in the section but not the maximum
6760 index. Therefore we have to run through all entries and find
6761 the maximum. */
252b5132 6762 everdef = (Elf_External_Verdef *) contents;
f631889e
UD		 6763 maxidx = 0;
6764 for (i = 0; i < hdr->sh_info; ++i)
6765 {
6766 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6767
062e2358
AM		 6768 if ((iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION)) > maxidx)
6769 maxidx = iverdefmem.vd_ndx & ((unsigned) VERSYM_VERSION);
f631889e 6770
d0fb9a8d
JJ		 6771 if (iverdefmem.vd_next
6772 > (size_t) (contents_end_def - (bfd_byte *) everdef))
6773 goto error_return;
6774
f631889e
UD		 6775 everdef = ((Elf_External_Verdef *)
6776 ((bfd_byte *) everdef + iverdefmem.vd_next));
6777 }
6778
fc0e6df6
PB		 6779 if (default_imported_symver)
6780 {
6781 if (freeidx > maxidx)
6782 maxidx = ++freeidx;
6783 else
6784 freeidx = ++maxidx;
6785 }
d0fb9a8d
JJ		 6786 elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, maxidx,
6787 sizeof (Elf_Internal_Verdef));
f631889e
UD		 6788 if (elf_tdata (abfd)->verdef == NULL)
6789 goto error_return;
6790
6791 elf_tdata (abfd)->cverdefs = maxidx;
6792
6793 everdef = (Elf_External_Verdef *) contents;
6794 iverdefarr = elf_tdata (abfd)->verdef;
6795 for (i = 0; i < hdr->sh_info; i++)
252b5132
RH		 6796 {
6797 Elf_External_Verdaux *everdaux;
6798 Elf_Internal_Verdaux *iverdaux;
6799 unsigned int j;
6800
f631889e
UD		 6801 _bfd_elf_swap_verdef_in (abfd, everdef, &iverdefmem);
6802
d0fb9a8d
JJ		 6803 if ((iverdefmem.vd_ndx & VERSYM_VERSION) == 0)
6804 {
6805error_return_verdef:
6806 elf_tdata (abfd)->verdef = NULL;
6807 elf_tdata (abfd)->cverdefs = 0;
6808 goto error_return;
6809 }
6810
f631889e
UD		 6811 iverdef = &iverdefarr[(iverdefmem.vd_ndx & VERSYM_VERSION) - 1];
6812 memcpy (iverdef, &iverdefmem, sizeof (Elf_Internal_Verdef));
252b5132
RH		 6813
6814 iverdef->vd_bfd = abfd;
6815
d0fb9a8d
JJ		 6816 if (iverdef->vd_cnt == 0)
6817 iverdef->vd_auxptr = NULL;
6818 else
6819 {
6820 iverdef->vd_auxptr = bfd_alloc2 (abfd, iverdef->vd_cnt,
6821 sizeof (Elf_Internal_Verdaux));
6822 if (iverdef->vd_auxptr == NULL)
6823 goto error_return_verdef;
6824 }
6825
6826 if (iverdef->vd_aux
6827 > (size_t) (contents_end_aux - (bfd_byte *) everdef))
6828 goto error_return_verdef;
252b5132
RH		 6829
6830 everdaux = ((Elf_External_Verdaux *)
6831 ((bfd_byte *) everdef + iverdef->vd_aux));
6832 iverdaux = iverdef->vd_auxptr;
6833 for (j = 0; j < iverdef->vd_cnt; j++, iverdaux++)
6834 {
6835 _bfd_elf_swap_verdaux_in (abfd, everdaux, iverdaux);
6836
6837 iverdaux->vda_nodename =
6838 bfd_elf_string_from_elf_section (abfd, hdr->sh_link,
6839 iverdaux->vda_name);
6840 if (iverdaux->vda_nodename == NULL)
d0fb9a8d 6841 goto error_return_verdef;
252b5132
RH		 6842
6843 if (j + 1 < iverdef->vd_cnt)
6844 iverdaux->vda_nextptr = iverdaux + 1;
6845 else
6846 iverdaux->vda_nextptr = NULL;
6847
d0fb9a8d
JJ		 6848 if (iverdaux->vda_next
6849 > (size_t) (contents_end_aux - (bfd_byte *) everdaux))
6850 goto error_return_verdef;
6851
252b5132
RH		 6852 everdaux = ((Elf_External_Verdaux *)
6853 ((bfd_byte *) everdaux + iverdaux->vda_next));
6854 }
6855
d0fb9a8d
JJ		 6856 if (iverdef->vd_cnt)
6857 iverdef->vd_nodename = iverdef->vd_auxptr->vda_nodename;
252b5132 6858
d0fb9a8d 6859 if ((size_t) (iverdef - iverdefarr) + 1 < maxidx)
252b5132
RH		 6860 iverdef->vd_nextdef = iverdef + 1;
6861 else
6862 iverdef->vd_nextdef = NULL;
6863
6864 everdef = ((Elf_External_Verdef *)
6865 ((bfd_byte *) everdef + iverdef->vd_next));
6866 }
6867
6868 free (contents);
6869 contents = NULL;
6870 }
fc0e6df6 6871 else if (default_imported_symver)
252b5132 6872 {
fc0e6df6
PB		 6873 if (freeidx < 3)
6874 freeidx = 3;
6875 else
6876 freeidx++;
252b5132 6877
d0fb9a8d
JJ		 6878 elf_tdata (abfd)->verdef = bfd_zalloc2 (abfd, freeidx,
6879 sizeof (Elf_Internal_Verdef));
fc0e6df6 6880 if (elf_tdata (abfd)->verdef == NULL)
252b5132
RH		 6881 goto error_return;
6882
fc0e6df6
PB		 6883 elf_tdata (abfd)->cverdefs = freeidx;
6884 }
252b5132 6885
fc0e6df6
PB		 6886 /* Create a default version based on the soname. */
6887 if (default_imported_symver)
6888 {
6889 Elf_Internal_Verdef *iverdef;
6890 Elf_Internal_Verdaux *iverdaux;
252b5132 6891
fc0e6df6 6892 iverdef = &elf_tdata (abfd)->verdef[freeidx - 1];;
252b5132 6893
fc0e6df6
PB		 6894 iverdef->vd_version = VER_DEF_CURRENT;
6895 iverdef->vd_flags = 0;
6896 iverdef->vd_ndx = freeidx;
6897 iverdef->vd_cnt = 1;
252b5132 6898
fc0e6df6 6899 iverdef->vd_bfd = abfd;
252b5132 6900
fc0e6df6
PB		 6901 iverdef->vd_nodename = bfd_elf_get_dt_soname (abfd);
6902 if (iverdef->vd_nodename == NULL)
d0fb9a8d 6903 goto error_return_verdef;
fc0e6df6 6904 iverdef->vd_nextdef = NULL;
d0fb9a8d
JJ		 6905 iverdef->vd_auxptr = bfd_alloc (abfd, sizeof (Elf_Internal_Verdaux));
6906 if (iverdef->vd_auxptr == NULL)
6907 goto error_return_verdef;
252b5132 6908
fc0e6df6
PB		 6909 iverdaux = iverdef->vd_auxptr;
6910 iverdaux->vda_nodename = iverdef->vd_nodename;
6911 iverdaux->vda_nextptr = NULL;
252b5132
RH		 6912 }
6913
b34976b6 6914 return TRUE;
252b5132
RH		 6915
6916 error_return:
5ed6aba4 6917 if (contents != NULL)
252b5132 6918 free (contents);
b34976b6 6919 return FALSE;
252b5132
RH		 6920}
6921\f
6922asymbol *
217aa764 6923_bfd_elf_make_empty_symbol (bfd *abfd)
252b5132
RH		 6924{
6925 elf_symbol_type *newsym;
dc810e39 6926 bfd_size_type amt = sizeof (elf_symbol_type);
252b5132 6927
217aa764 6928 newsym = bfd_zalloc (abfd, amt);
252b5132
RH		 6929 if (!newsym)
6930 return NULL;
6931 else
6932 {
6933 newsym->symbol.the_bfd = abfd;
6934 return &newsym->symbol;
6935 }
6936}
6937
6938void
217aa764
AM		 6939_bfd_elf_get_symbol_info (bfd *abfd ATTRIBUTE_UNUSED,
6940 asymbol *symbol,
6941 symbol_info *ret)
252b5132
RH		 6942{
6943 bfd_symbol_info (symbol, ret);
6944}
6945
6946/* Return whether a symbol name implies a local symbol. Most targets
6947 use this function for the is_local_label_name entry point, but some
6948 override it. */
6949
b34976b6 6950bfd_boolean
217aa764
AM		 6951_bfd_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED,
6952 const char *name)
252b5132
RH		 6953{
6954 /* Normal local symbols start with ``.L''. */
6955 if (name[0] == '.' && name[1] == 'L')
b34976b6 6956 return TRUE;
252b5132
RH		 6957
6958 /* At least some SVR4 compilers (e.g., UnixWare 2.1 cc) generate
6959 DWARF debugging symbols starting with ``..''. */
6960 if (name[0] == '.' && name[1] == '.')
b34976b6 6961 return TRUE;
252b5132
RH		 6962
6963 /* gcc will sometimes generate symbols beginning with ``_.L_'' when
6964 emitting DWARF debugging output. I suspect this is actually a
6965 small bug in gcc (it calls ASM_OUTPUT_LABEL when it should call
6966 ASM_GENERATE_INTERNAL_LABEL, and this causes the leading
6967 underscore to be emitted on some ELF targets). For ease of use,
6968 we treat such symbols as local. */
6969 if (name[0] == '_' && name[1] == '.' && name[2] == 'L' && name[3] == '_')
b34976b6 6970 return TRUE;
252b5132 6971
b34976b6 6972 return FALSE;
252b5132
RH		 6973}
6974
6975alent *
217aa764
AM		 6976_bfd_elf_get_lineno (bfd *abfd ATTRIBUTE_UNUSED,
6977 asymbol *symbol ATTRIBUTE_UNUSED)
252b5132
RH		 6978{
6979 abort ();
6980 return NULL;
6981}
6982
b34976b6 6983bfd_boolean
217aa764
AM		 6984_bfd_elf_set_arch_mach (bfd *abfd,
6985 enum bfd_architecture arch,
6986 unsigned long machine)
252b5132
RH		 6987{
6988 /* If this isn't the right architecture for this backend, and this
6989 isn't the generic backend, fail. */
6990 if (arch != get_elf_backend_data (abfd)->arch
6991 && arch != bfd_arch_unknown
6992 && get_elf_backend_data (abfd)->arch != bfd_arch_unknown)
b34976b6 6993 return FALSE;
252b5132
RH		 6994
6995 return bfd_default_set_arch_mach (abfd, arch, machine);
6996}
6997
d1fad7c6
NC		 6998/* Find the function to a particular section and offset,
6999 for error reporting. */
252b5132 7000
b34976b6 7001static bfd_boolean
217aa764
AM		 7002elf_find_function (bfd *abfd ATTRIBUTE_UNUSED,
7003 asection *section,
7004 asymbol **symbols,
7005 bfd_vma offset,
7006 const char **filename_ptr,
7007 const char **functionname_ptr)
252b5132 7008{
252b5132 7009 const char *filename;
57426232 7010 asymbol *func, *file;
252b5132
RH		 7011 bfd_vma low_func;
7012 asymbol **p;
57426232
JB		 7013 /* ??? Given multiple file symbols, it is impossible to reliably
7014 choose the right file name for global symbols. File symbols are
7015 local symbols, and thus all file symbols must sort before any
7016 global symbols. The ELF spec may be interpreted to say that a
7017 file symbol must sort before other local symbols, but currently
7018 ld -r doesn't do this. So, for ld -r output, it is possible to
7019 make a better choice of file name for local symbols by ignoring
7020 file symbols appearing after a given local symbol. */
7021 enum { nothing_seen, symbol_seen, file_after_symbol_seen } state;
252b5132 7022
252b5132
RH		 7023 filename = NULL;
7024 func = NULL;
57426232 7025 file = NULL;
252b5132 7026 low_func = 0;
57426232 7027 state = nothing_seen;
252b5132
RH		 7028
7029 for (p = symbols; *p != NULL; p++)
7030 {
7031 elf_symbol_type *q;
7032
7033 q = (elf_symbol_type *) *p;
7034
252b5132
RH		 7035 switch (ELF_ST_TYPE (q->internal_elf_sym.st_info))
7036 {
7037 default:
7038 break;
7039 case STT_FILE:
57426232
JB		 7040 file = &q->symbol;
7041 if (state == symbol_seen)
7042 state = file_after_symbol_seen;
7043 continue;
252b5132
RH		 7044 case STT_NOTYPE:
7045 case STT_FUNC:
6b40fcba 7046 if (bfd_get_section (&q->symbol) == section
252b5132
RH		 7047 && q->symbol.value >= low_func
7048 && q->symbol.value <= offset)
7049 {
7050 func = (asymbol *) q;
7051 low_func = q->symbol.value;
a1923858
AM		 7052 filename = NULL;
7053 if (file != NULL
7054 && (ELF_ST_BIND (q->internal_elf_sym.st_info) == STB_LOCAL
7055 || state != file_after_symbol_seen))
57426232 7056 filename = bfd_asymbol_name (file);
252b5132
RH		 7057 }
7058 break;
7059 }
57426232
JB		 7060 if (state == nothing_seen)
7061 state = symbol_seen;
252b5132
RH		 7062 }
7063
7064 if (func == NULL)
b34976b6 7065 return FALSE;
252b5132 7066
d1fad7c6
NC		 7067 if (filename_ptr)
7068 *filename_ptr = filename;
7069 if (functionname_ptr)
7070 *functionname_ptr = bfd_asymbol_name (func);
7071
b34976b6 7072 return TRUE;
d1fad7c6
NC		 7073}
7074
7075/* Find the nearest line to a particular section and offset,
7076 for error reporting. */
7077
b34976b6 7078bfd_boolean
217aa764
AM		 7079_bfd_elf_find_nearest_line (bfd *abfd,
7080 asection *section,
7081 asymbol **symbols,
7082 bfd_vma offset,
7083 const char **filename_ptr,
7084 const char **functionname_ptr,
7085 unsigned int *line_ptr)
d1fad7c6 7086{
b34976b6 7087 bfd_boolean found;
d1fad7c6
NC		 7088
7089 if (_bfd_dwarf1_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 7090 filename_ptr, functionname_ptr,
7091 line_ptr))
d1fad7c6
NC		 7092 {
7093 if (!*functionname_ptr)
4e8a9624
AM		 7094 elf_find_function (abfd, section, symbols, offset,
7095 *filename_ptr ? NULL : filename_ptr,
7096 functionname_ptr);
7097
b34976b6 7098 return TRUE;
d1fad7c6
NC		 7099 }
7100
7101 if (_bfd_dwarf2_find_nearest_line (abfd, section, symbols, offset,
4e8a9624
AM		 7102 filename_ptr, functionname_ptr,
7103 line_ptr, 0,
7104 &elf_tdata (abfd)->dwarf2_find_line_info))
d1fad7c6
NC		 7105 {
7106 if (!*functionname_ptr)
4e8a9624
AM		 7107 elf_find_function (abfd, section, symbols, offset,
7108 *filename_ptr ? NULL : filename_ptr,
7109 functionname_ptr);
7110
b34976b6 7111 return TRUE;
d1fad7c6
NC		 7112 }
7113
7114 if (! _bfd_stab_section_find_nearest_line (abfd, symbols, section, offset,
4e8a9624
AM		 7115 &found, filename_ptr,
7116 functionname_ptr, line_ptr,
7117 &elf_tdata (abfd)->line_info))
b34976b6 7118 return FALSE;
dc43ada5 7119 if (found && (*functionname_ptr || *line_ptr))
b34976b6 7120 return TRUE;
d1fad7c6
NC		 7121
7122 if (symbols == NULL)
b34976b6 7123 return FALSE;
d1fad7c6
NC		 7124
7125 if (! elf_find_function (abfd, section, symbols, offset,
4e8a9624 7126 filename_ptr, functionname_ptr))
b34976b6 7127 return FALSE;
d1fad7c6 7128
252b5132 7129 *line_ptr = 0;
b34976b6 7130 return TRUE;
252b5132
RH		 7131}
7132
5420f73d
L		 7133/* Find the line for a symbol. */
7134
7135bfd_boolean
7136_bfd_elf_find_line (bfd *abfd, asymbol **symbols, asymbol *symbol,
7137 const char **filename_ptr, unsigned int *line_ptr)
7138{
7139 return _bfd_dwarf2_find_line (abfd, symbols, symbol,
7140 filename_ptr, line_ptr, 0,
7141 &elf_tdata (abfd)->dwarf2_find_line_info);
7142}
7143
4ab527b0
FF		 7144/* After a call to bfd_find_nearest_line, successive calls to
7145 bfd_find_inliner_info can be used to get source information about
7146 each level of function inlining that terminated at the address
7147 passed to bfd_find_nearest_line. Currently this is only supported
7148 for DWARF2 with appropriate DWARF3 extensions. */
7149
7150bfd_boolean
7151_bfd_elf_find_inliner_info (bfd *abfd,
7152 const char **filename_ptr,
7153 const char **functionname_ptr,
7154 unsigned int *line_ptr)
7155{
7156 bfd_boolean found;
7157 found = _bfd_dwarf2_find_inliner_info (abfd, filename_ptr,
7158 functionname_ptr, line_ptr,
7159 & elf_tdata (abfd)->dwarf2_find_line_info);
7160 return found;
7161}
7162
252b5132 7163int
a6b96beb 7164_bfd_elf_sizeof_headers (bfd *abfd, struct bfd_link_info *info)
252b5132 7165{
8ded5a0f
AM		 7166 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
7167 int ret = bed->s->sizeof_ehdr;
252b5132 7168
a6b96beb 7169 if (!info->relocatable)
8ded5a0f 7170 {
62d7a5f6 7171 bfd_size_type phdr_size = elf_tdata (abfd)->program_header_size;
8ded5a0f 7172
62d7a5f6
AM		 7173 if (phdr_size == (bfd_size_type) -1)
7174 {
7175 struct elf_segment_map *m;
7176
7177 phdr_size = 0;
7178 for (m = elf_tdata (abfd)->segment_map; m != NULL; m = m->next)
7179 phdr_size += bed->s->sizeof_phdr;
8ded5a0f 7180
62d7a5f6
AM		 7181 if (phdr_size == 0)
7182 phdr_size = get_program_header_size (abfd, info);
7183 }
8ded5a0f
AM		 7184
7185 elf_tdata (abfd)->program_header_size = phdr_size;
7186 ret += phdr_size;
7187 }
7188
252b5132
RH		 7189 return ret;
7190}
7191
b34976b6 7192bfd_boolean
217aa764
AM		 7193_bfd_elf_set_section_contents (bfd *abfd,
7194 sec_ptr section,
0f867abe 7195 const void *location,
217aa764
AM		 7196 file_ptr offset,
7197 bfd_size_type count)
252b5132
RH		 7198{
7199 Elf_Internal_Shdr *hdr;
dc810e39 7200 bfd_signed_vma pos;
252b5132
RH		 7201
7202 if (! abfd->output_has_begun
217aa764 7203 && ! _bfd_elf_compute_section_file_positions (abfd, NULL))
b34976b6 7204 return FALSE;
252b5132
RH		 7205
7206 hdr = &elf_section_data (section)->this_hdr;
dc810e39
AM		 7207 pos = hdr->sh_offset + offset;
7208 if (bfd_seek (abfd, pos, SEEK_SET) != 0
7209 || bfd_bwrite (location, count, abfd) != count)
b34976b6 7210 return FALSE;
252b5132 7211
b34976b6 7212 return TRUE;
252b5132
RH		 7213}
7214
7215void
217aa764
AM		 7216_bfd_elf_no_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
7217 arelent *cache_ptr ATTRIBUTE_UNUSED,
7218 Elf_Internal_Rela *dst ATTRIBUTE_UNUSED)
252b5132
RH		 7219{
7220 abort ();
7221}
7222
252b5132
RH		 7223/* Try to convert a non-ELF reloc into an ELF one. */
7224
b34976b6 7225bfd_boolean
217aa764 7226_bfd_elf_validate_reloc (bfd *abfd, arelent *areloc)
252b5132 7227{
c044fabd 7228 /* Check whether we really have an ELF howto. */
252b5132
RH		 7229
7230 if ((*areloc->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec)
7231 {
7232 bfd_reloc_code_real_type code;
7233 reloc_howto_type *howto;
7234
7235 /* Alien reloc: Try to determine its type to replace it with an
c044fabd 7236 equivalent ELF reloc. */
252b5132
RH		 7237
7238 if (areloc->howto->pc_relative)
7239 {
7240 switch (areloc->howto->bitsize)
7241 {
7242 case 8:
7243 code = BFD_RELOC_8_PCREL;
7244 break;
7245 case 12:
7246 code = BFD_RELOC_12_PCREL;
7247 break;
7248 case 16:
7249 code = BFD_RELOC_16_PCREL;
7250 break;
7251 case 24:
7252 code = BFD_RELOC_24_PCREL;
7253 break;
7254 case 32:
7255 code = BFD_RELOC_32_PCREL;
7256 break;
7257 case 64:
7258 code = BFD_RELOC_64_PCREL;
7259 break;
7260 default:
7261 goto fail;
7262 }
7263
7264 howto = bfd_reloc_type_lookup (abfd, code);
7265
7266 if (areloc->howto->pcrel_offset != howto->pcrel_offset)
7267 {
7268 if (howto->pcrel_offset)
7269 areloc->addend += areloc->address;
7270 else
7271 areloc->addend -= areloc->address; /* addend is unsigned!! */
7272 }
7273 }
7274 else
7275 {
7276 switch (areloc->howto->bitsize)
7277 {
7278 case 8:
7279 code = BFD_RELOC_8;
7280 break;
7281 case 14:
7282 code = BFD_RELOC_14;
7283 break;
7284 case 16:
7285 code = BFD_RELOC_16;
7286 break;
7287 case 26:
7288 code = BFD_RELOC_26;
7289 break;
7290 case 32:
7291 code = BFD_RELOC_32;
7292 break;
7293 case 64:
7294 code = BFD_RELOC_64;
7295 break;
7296 default:
7297 goto fail;
7298 }
7299
7300 howto = bfd_reloc_type_lookup (abfd, code);
7301 }
7302
7303 if (howto)
7304 areloc->howto = howto;
7305 else
7306 goto fail;
7307 }
7308
b34976b6 7309 return TRUE;
252b5132
RH		 7310
7311 fail:
7312 (*_bfd_error_handler)
d003868e
AM		 7313 (_("%B: unsupported relocation type %s"),
7314 abfd, areloc->howto->name);
252b5132 7315 bfd_set_error (bfd_error_bad_value);
b34976b6 7316 return FALSE;
252b5132
RH		 7317}
7318
b34976b6 7319bfd_boolean
217aa764 7320_bfd_elf_close_and_cleanup (bfd *abfd)
252b5132
RH		 7321{
7322 if (bfd_get_format (abfd) == bfd_object)
7323 {
b25e3d87 7324 if (elf_tdata (abfd) != NULL && elf_shstrtab (abfd) != NULL)
2b0f7ef9 7325 _bfd_elf_strtab_free (elf_shstrtab (abfd));
6f140a15 7326 _bfd_dwarf2_cleanup_debug_info (abfd);
252b5132
RH		 7327 }
7328
7329 return _bfd_generic_close_and_cleanup (abfd);
7330}
7331
7332/* For Rel targets, we encode meaningful data for BFD_RELOC_VTABLE_ENTRY
7333 in the relocation's offset. Thus we cannot allow any sort of sanity
7334 range-checking to interfere. There is nothing else to do in processing
7335 this reloc. */
7336
7337bfd_reloc_status_type
217aa764
AM		 7338_bfd_elf_rel_vtable_reloc_fn
7339 (bfd *abfd ATTRIBUTE_UNUSED, arelent *re ATTRIBUTE_UNUSED,
fc0a2244 7340 struct bfd_symbol *symbol ATTRIBUTE_UNUSED,
217aa764
AM		 7341 void *data ATTRIBUTE_UNUSED, asection *is ATTRIBUTE_UNUSED,
7342 bfd *obfd ATTRIBUTE_UNUSED, char **errmsg ATTRIBUTE_UNUSED)
252b5132
RH		 7343{
7344 return bfd_reloc_ok;
7345}
252b5132
RH		 7346\f
7347/* Elf core file support. Much of this only works on native
7348 toolchains, since we rely on knowing the
7349 machine-dependent procfs structure in order to pick
c044fabd 7350 out details about the corefile. */
252b5132
RH		 7351
7352#ifdef HAVE_SYS_PROCFS_H
7353# include <sys/procfs.h>
7354#endif
7355
c044fabd 7356/* FIXME: this is kinda wrong, but it's what gdb wants. */
252b5132
RH		 7357
7358static int
217aa764 7359elfcore_make_pid (bfd *abfd)
252b5132
RH		 7360{
7361 return ((elf_tdata (abfd)->core_lwpid << 16)
7362 + (elf_tdata (abfd)->core_pid));
7363}
7364
252b5132
RH		 7365/* If there isn't a section called NAME, make one, using
7366 data from SECT. Note, this function will generate a
7367 reference to NAME, so you shouldn't deallocate or
c044fabd 7368 overwrite it. */
252b5132 7369
b34976b6 7370static bfd_boolean
217aa764 7371elfcore_maybe_make_sect (bfd *abfd, char *name, asection *sect)
252b5132 7372{
c044fabd 7373 asection *sect2;
252b5132
RH		 7374
7375 if (bfd_get_section_by_name (abfd, name) != NULL)
b34976b6 7376 return TRUE;
252b5132 7377
117ed4f8 7378 sect2 = bfd_make_section_with_flags (abfd, name, sect->flags);
252b5132 7379 if (sect2 == NULL)
b34976b6 7380 return FALSE;
252b5132 7381
eea6121a 7382 sect2->size = sect->size;
252b5132 7383 sect2->filepos = sect->filepos;
252b5132 7384 sect2->alignment_power = sect->alignment_power;
b34976b6 7385 return TRUE;
252b5132
RH		 7386}
7387
bb0082d6
AM		 7388/* Create a pseudosection containing SIZE bytes at FILEPOS. This
7389 actually creates up to two pseudosections:
7390 - For the single-threaded case, a section named NAME, unless
7391 such a section already exists.
7392 - For the multi-threaded case, a section named "NAME/PID", where
7393 PID is elfcore_make_pid (abfd).
7394 Both pseudosections have identical contents. */
b34976b6 7395bfd_boolean
217aa764
AM		 7396_bfd_elfcore_make_pseudosection (bfd *abfd,
7397 char *name,
7398 size_t size,
7399 ufile_ptr filepos)
bb0082d6
AM		 7400{
7401 char buf[100];
7402 char *threaded_name;
d4c88bbb 7403 size_t len;
bb0082d6
AM		 7404 asection *sect;
7405
7406 /* Build the section name. */
7407
7408 sprintf (buf, "%s/%d", name, elfcore_make_pid (abfd));
d4c88bbb 7409 len = strlen (buf) + 1;
217aa764 7410 threaded_name = bfd_alloc (abfd, len);
bb0082d6 7411 if (threaded_name == NULL)
b34976b6 7412 return FALSE;
d4c88bbb 7413 memcpy (threaded_name, buf, len);
bb0082d6 7414
117ed4f8
AM		 7415 sect = bfd_make_section_anyway_with_flags (abfd, threaded_name,
7416 SEC_HAS_CONTENTS);
bb0082d6 7417 if (sect == NULL)
b34976b6 7418 return FALSE;
eea6121a 7419 sect->size = size;
bb0082d6 7420 sect->filepos = filepos;
bb0082d6
AM		 7421 sect->alignment_power = 2;
7422
936e320b 7423 return elfcore_maybe_make_sect (abfd, name, sect);
bb0082d6
AM		 7424}
7425
252b5132 7426/* prstatus_t exists on:
4a938328 7427 solaris 2.5+
252b5132
RH		 7428 linux 2.[01] + glibc
7429 unixware 4.2
7430*/
7431
7432#if defined (HAVE_PRSTATUS_T)
a7b97311 7433
b34976b6 7434static bfd_boolean
217aa764 7435elfcore_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 7436{
eea6121a 7437 size_t size;
7ee38065 7438 int offset;
252b5132 7439
4a938328
MS		 7440 if (note->descsz == sizeof (prstatus_t))
7441 {
7442 prstatus_t prstat;
252b5132 7443
eea6121a 7444 size = sizeof (prstat.pr_reg);
7ee38065 7445 offset = offsetof (prstatus_t, pr_reg);
4a938328 7446 memcpy (&prstat, note->descdata, sizeof (prstat));
252b5132 7447
fa49d224
NC		 7448 /* Do not overwrite the core signal if it
7449 has already been set by another thread. */
7450 if (elf_tdata (abfd)->core_signal == 0)
7451 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4a938328 7452 elf_tdata (abfd)->core_pid = prstat.pr_pid;
252b5132 7453
4a938328
MS		 7454 /* pr_who exists on:
7455 solaris 2.5+
7456 unixware 4.2
7457 pr_who doesn't exist on:
7458 linux 2.[01]
7459 */
252b5132 7460#if defined (HAVE_PRSTATUS_T_PR_WHO)
4a938328 7461 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
252b5132 7462#endif
4a938328 7463 }
7ee38065 7464#if defined (HAVE_PRSTATUS32_T)
4a938328
MS		 7465 else if (note->descsz == sizeof (prstatus32_t))
7466 {
7467 /* 64-bit host, 32-bit corefile */
7468 prstatus32_t prstat;
7469
eea6121a 7470 size = sizeof (prstat.pr_reg);
7ee38065 7471 offset = offsetof (prstatus32_t, pr_reg);
4a938328
MS		 7472 memcpy (&prstat, note->descdata, sizeof (prstat));
7473
fa49d224
NC		 7474 /* Do not overwrite the core signal if it
7475 has already been set by another thread. */
7476 if (elf_tdata (abfd)->core_signal == 0)
7477 elf_tdata (abfd)->core_signal = prstat.pr_cursig;
4a938328
MS		 7478 elf_tdata (abfd)->core_pid = prstat.pr_pid;
7479
7480 /* pr_who exists on:
7481 solaris 2.5+
7482 unixware 4.2
7483 pr_who doesn't exist on:
7484 linux 2.[01]
7485 */
7ee38065 7486#if defined (HAVE_PRSTATUS32_T_PR_WHO)
4a938328
MS		 7487 elf_tdata (abfd)->core_lwpid = prstat.pr_who;
7488#endif
7489 }
7ee38065 7490#endif /* HAVE_PRSTATUS32_T */
4a938328
MS		 7491 else
7492 {
7493 /* Fail - we don't know how to handle any other
7494 note size (ie. data object type). */
b34976b6 7495 return TRUE;
4a938328 7496 }
252b5132 7497
bb0082d6 7498 /* Make a ".reg/999" section and a ".reg" section. */
936e320b 7499 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
eea6121a 7500 size, note->descpos + offset);
252b5132
RH		 7501}
7502#endif /* defined (HAVE_PRSTATUS_T) */
7503
bb0082d6 7504/* Create a pseudosection containing the exact contents of NOTE. */
b34976b6 7505static bfd_boolean
217aa764
AM		 7506elfcore_make_note_pseudosection (bfd *abfd,
7507 char *name,
7508 Elf_Internal_Note *note)
252b5132 7509{
936e320b
AM		 7510 return _bfd_elfcore_make_pseudosection (abfd, name,
7511 note->descsz, note->descpos);
252b5132
RH		 7512}
7513
ff08c6bb
JB		 7514/* There isn't a consistent prfpregset_t across platforms,
7515 but it doesn't matter, because we don't have to pick this
c044fabd
KH		 7516 data structure apart. */
7517
b34976b6 7518static bfd_boolean
217aa764 7519elfcore_grok_prfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 7520{
7521 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7522}
7523
ff08c6bb
JB		 7524/* Linux dumps the Intel SSE regs in a note named "LINUX" with a note
7525 type of 5 (NT_PRXFPREG). Just include the whole note's contents
7526 literally. */
c044fabd 7527
b34976b6 7528static bfd_boolean
217aa764 7529elfcore_grok_prxfpreg (bfd *abfd, Elf_Internal_Note *note)
ff08c6bb
JB		 7530{
7531 return elfcore_make_note_pseudosection (abfd, ".reg-xfp", note);
7532}
7533
252b5132 7534#if defined (HAVE_PRPSINFO_T)
4a938328 7535typedef prpsinfo_t elfcore_psinfo_t;
7ee38065 7536#if defined (HAVE_PRPSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 7537typedef prpsinfo32_t elfcore_psinfo32_t;
7538#endif
252b5132
RH		 7539#endif
7540
7541#if defined (HAVE_PSINFO_T)
4a938328 7542typedef psinfo_t elfcore_psinfo_t;
7ee38065 7543#if defined (HAVE_PSINFO32_T) /* Sparc64 cross Sparc32 */
4a938328
MS		 7544typedef psinfo32_t elfcore_psinfo32_t;
7545#endif
252b5132
RH		 7546#endif
7547
252b5132
RH		 7548/* return a malloc'ed copy of a string at START which is at
7549 most MAX bytes long, possibly without a terminating '\0'.
c044fabd 7550 the copy will always have a terminating '\0'. */
252b5132 7551
936e320b 7552char *
217aa764 7553_bfd_elfcore_strndup (bfd *abfd, char *start, size_t max)
252b5132 7554{
dc810e39 7555 char *dups;
c044fabd 7556 char *end = memchr (start, '\0', max);
dc810e39 7557 size_t len;
252b5132
RH		 7558
7559 if (end == NULL)
7560 len = max;
7561 else
7562 len = end - start;
7563
217aa764 7564 dups = bfd_alloc (abfd, len + 1);
dc810e39 7565 if (dups == NULL)
252b5132
RH		 7566 return NULL;
7567
dc810e39
AM		 7568 memcpy (dups, start, len);
7569 dups[len] = '\0';
252b5132 7570
dc810e39 7571 return dups;
252b5132
RH		 7572}
7573
bb0082d6 7574#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
b34976b6 7575static bfd_boolean
217aa764 7576elfcore_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
252b5132 7577{
4a938328
MS		 7578 if (note->descsz == sizeof (elfcore_psinfo_t))
7579 {
7580 elfcore_psinfo_t psinfo;
252b5132 7581
7ee38065 7582 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 7583
4a938328 7584 elf_tdata (abfd)->core_program
936e320b
AM		 7585 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7586 sizeof (psinfo.pr_fname));
252b5132 7587
4a938328 7588 elf_tdata (abfd)->core_command
936e320b
AM		 7589 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7590 sizeof (psinfo.pr_psargs));
4a938328 7591 }
7ee38065 7592#if defined (HAVE_PRPSINFO32_T) || defined (HAVE_PSINFO32_T)
4a938328
MS		 7593 else if (note->descsz == sizeof (elfcore_psinfo32_t))
7594 {
7595 /* 64-bit host, 32-bit corefile */
7596 elfcore_psinfo32_t psinfo;
7597
7ee38065 7598 memcpy (&psinfo, note->descdata, sizeof (psinfo));
252b5132 7599
4a938328 7600 elf_tdata (abfd)->core_program
936e320b
AM		 7601 = _bfd_elfcore_strndup (abfd, psinfo.pr_fname,
7602 sizeof (psinfo.pr_fname));
4a938328
MS		 7603
7604 elf_tdata (abfd)->core_command
936e320b
AM		 7605 = _bfd_elfcore_strndup (abfd, psinfo.pr_psargs,
7606 sizeof (psinfo.pr_psargs));
4a938328
MS		 7607 }
7608#endif
7609
7610 else
7611 {
7612 /* Fail - we don't know how to handle any other
7613 note size (ie. data object type). */
b34976b6 7614 return TRUE;
4a938328 7615 }
252b5132
RH		 7616
7617 /* Note that for some reason, a spurious space is tacked
7618 onto the end of the args in some (at least one anyway)
c044fabd 7619 implementations, so strip it off if it exists. */
252b5132
RH		 7620
7621 {
c044fabd 7622 char *command = elf_tdata (abfd)->core_command;
252b5132
RH		 7623 int n = strlen (command);
7624
7625 if (0 < n && command[n - 1] == ' ')
7626 command[n - 1] = '\0';
7627 }
7628
b34976b6 7629 return TRUE;
252b5132
RH		 7630}
7631#endif /* defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T) */
7632
252b5132 7633#if defined (HAVE_PSTATUS_T)
b34976b6 7634static bfd_boolean
217aa764 7635elfcore_grok_pstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132 7636{
f572a39d
AM		 7637 if (note->descsz == sizeof (pstatus_t)
7638#if defined (HAVE_PXSTATUS_T)
7639 || note->descsz == sizeof (pxstatus_t)
7640#endif
7641 )
4a938328
MS		 7642 {
7643 pstatus_t pstat;
252b5132 7644
4a938328 7645 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 7646
4a938328
MS		 7647 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7648 }
7ee38065 7649#if defined (HAVE_PSTATUS32_T)
4a938328
MS		 7650 else if (note->descsz == sizeof (pstatus32_t))
7651 {
7652 /* 64-bit host, 32-bit corefile */
7653 pstatus32_t pstat;
252b5132 7654
4a938328 7655 memcpy (&pstat, note->descdata, sizeof (pstat));
252b5132 7656
4a938328
MS		 7657 elf_tdata (abfd)->core_pid = pstat.pr_pid;
7658 }
7659#endif
252b5132
RH		 7660 /* Could grab some more details from the "representative"
7661 lwpstatus_t in pstat.pr_lwp, but we'll catch it all in an
c044fabd 7662 NT_LWPSTATUS note, presumably. */
252b5132 7663
b34976b6 7664 return TRUE;
252b5132
RH		 7665}
7666#endif /* defined (HAVE_PSTATUS_T) */
7667
252b5132 7668#if defined (HAVE_LWPSTATUS_T)
b34976b6 7669static bfd_boolean
217aa764 7670elfcore_grok_lwpstatus (bfd *abfd, Elf_Internal_Note *note)
252b5132
RH		 7671{
7672 lwpstatus_t lwpstat;
7673 char buf[100];
c044fabd 7674 char *name;
d4c88bbb 7675 size_t len;
c044fabd 7676 asection *sect;
252b5132 7677
f572a39d
AM		 7678 if (note->descsz != sizeof (lwpstat)
7679#if defined (HAVE_LWPXSTATUS_T)
7680 && note->descsz != sizeof (lwpxstatus_t)
7681#endif
7682 )
b34976b6 7683 return TRUE;
252b5132
RH		 7684
7685 memcpy (&lwpstat, note->descdata, sizeof (lwpstat));
7686
7687 elf_tdata (abfd)->core_lwpid = lwpstat.pr_lwpid;
7688 elf_tdata (abfd)->core_signal = lwpstat.pr_cursig;
7689
c044fabd 7690 /* Make a ".reg/999" section. */
252b5132
RH		 7691
7692 sprintf (buf, ".reg/%d", elfcore_make_pid (abfd));
d4c88bbb 7693 len = strlen (buf) + 1;
217aa764 7694 name = bfd_alloc (abfd, len);
252b5132 7695 if (name == NULL)
b34976b6 7696 return FALSE;
d4c88bbb 7697 memcpy (name, buf, len);
252b5132 7698
117ed4f8 7699 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 7700 if (sect == NULL)
b34976b6 7701 return FALSE;
252b5132
RH		 7702
7703#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 7704 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.gregs);
252b5132
RH		 7705 sect->filepos = note->descpos
7706 + offsetof (lwpstatus_t, pr_context.uc_mcontext.gregs);
7707#endif
7708
7709#if defined (HAVE_LWPSTATUS_T_PR_REG)
eea6121a 7710 sect->size = sizeof (lwpstat.pr_reg);
252b5132
RH		 7711 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_reg);
7712#endif
7713
252b5132
RH		 7714 sect->alignment_power = 2;
7715
7716 if (!elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 7717 return FALSE;
252b5132
RH		 7718
7719 /* Make a ".reg2/999" section */
7720
7721 sprintf (buf, ".reg2/%d", elfcore_make_pid (abfd));
d4c88bbb 7722 len = strlen (buf) + 1;
217aa764 7723 name = bfd_alloc (abfd, len);
252b5132 7724 if (name == NULL)
b34976b6 7725 return FALSE;
d4c88bbb 7726 memcpy (name, buf, len);
252b5132 7727
117ed4f8 7728 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
252b5132 7729 if (sect == NULL)
b34976b6 7730 return FALSE;
252b5132
RH		 7731
7732#if defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
eea6121a 7733 sect->size = sizeof (lwpstat.pr_context.uc_mcontext.fpregs);
252b5132
RH		 7734 sect->filepos = note->descpos
7735 + offsetof (lwpstatus_t, pr_context.uc_mcontext.fpregs);
7736#endif
7737
7738#if defined (HAVE_LWPSTATUS_T_PR_FPREG)
eea6121a 7739 sect->size = sizeof (lwpstat.pr_fpreg);
252b5132
RH		 7740 sect->filepos = note->descpos + offsetof (lwpstatus_t, pr_fpreg);
7741#endif
7742
252b5132
RH		 7743 sect->alignment_power = 2;
7744
936e320b 7745 return elfcore_maybe_make_sect (abfd, ".reg2", sect);
252b5132
RH		 7746}
7747#endif /* defined (HAVE_LWPSTATUS_T) */
7748
16e9c715 7749#if defined (HAVE_WIN32_PSTATUS_T)
b34976b6 7750static bfd_boolean
217aa764 7751elfcore_grok_win32pstatus (bfd *abfd, Elf_Internal_Note *note)
16e9c715
NC		 7752{
7753 char buf[30];
c044fabd 7754 char *name;
d4c88bbb 7755 size_t len;
c044fabd 7756 asection *sect;
16e9c715
NC		 7757 win32_pstatus_t pstatus;
7758
7759 if (note->descsz < sizeof (pstatus))
b34976b6 7760 return TRUE;
16e9c715 7761
e8eab623 7762 memcpy (&pstatus, note->descdata, sizeof (pstatus));
c044fabd
KH		 7763
7764 switch (pstatus.data_type)
16e9c715
NC		 7765 {
7766 case NOTE_INFO_PROCESS:
7767 /* FIXME: need to add ->core_command. */
7768 elf_tdata (abfd)->core_signal = pstatus.data.process_info.signal;
7769 elf_tdata (abfd)->core_pid = pstatus.data.process_info.pid;
c044fabd 7770 break;
16e9c715
NC		 7771
7772 case NOTE_INFO_THREAD:
7773 /* Make a ".reg/999" section. */
1f170678 7774 sprintf (buf, ".reg/%ld", (long) pstatus.data.thread_info.tid);
c044fabd 7775
d4c88bbb 7776 len = strlen (buf) + 1;
217aa764 7777 name = bfd_alloc (abfd, len);
16e9c715 7778 if (name == NULL)
b34976b6 7779 return FALSE;
c044fabd 7780
d4c88bbb 7781 memcpy (name, buf, len);
16e9c715 7782
117ed4f8 7783 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
16e9c715 7784 if (sect == NULL)
b34976b6 7785 return FALSE;
c044fabd 7786
eea6121a 7787 sect->size = sizeof (pstatus.data.thread_info.thread_context);
079e9a2f
AM		 7788 sect->filepos = (note->descpos
7789 + offsetof (struct win32_pstatus,
7790 data.thread_info.thread_context));
16e9c715
NC		 7791 sect->alignment_power = 2;
7792
7793 if (pstatus.data.thread_info.is_active_thread)
7794 if (! elfcore_maybe_make_sect (abfd, ".reg", sect))
b34976b6 7795 return FALSE;
16e9c715
NC		 7796 break;
7797
7798 case NOTE_INFO_MODULE:
7799 /* Make a ".module/xxxxxxxx" section. */
1f170678
AM		 7800 sprintf (buf, ".module/%08lx",
7801 (long) pstatus.data.module_info.base_address);
c044fabd 7802
d4c88bbb 7803 len = strlen (buf) + 1;
217aa764 7804 name = bfd_alloc (abfd, len);
16e9c715 7805 if (name == NULL)
b34976b6 7806 return FALSE;
c044fabd 7807
d4c88bbb 7808 memcpy (name, buf, len);
252b5132 7809
117ed4f8 7810 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
c044fabd 7811
16e9c715 7812 if (sect == NULL)
b34976b6 7813 return FALSE;
c044fabd 7814
eea6121a 7815 sect->size = note->descsz;
16e9c715 7816 sect->filepos = note->descpos;
16e9c715
NC		 7817 sect->alignment_power = 2;
7818 break;
7819
7820 default:
b34976b6 7821 return TRUE;
16e9c715
NC		 7822 }
7823
b34976b6 7824 return TRUE;
16e9c715
NC		 7825}
7826#endif /* HAVE_WIN32_PSTATUS_T */
252b5132 7827
b34976b6 7828static bfd_boolean
217aa764 7829elfcore_grok_note (bfd *abfd, Elf_Internal_Note *note)
252b5132 7830{
9c5bfbb7 7831 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
bb0082d6 7832
252b5132
RH		 7833 switch (note->type)
7834 {
7835 default:
b34976b6 7836 return TRUE;
252b5132 7837
252b5132 7838 case NT_PRSTATUS:
bb0082d6
AM		 7839 if (bed->elf_backend_grok_prstatus)
7840 if ((*bed->elf_backend_grok_prstatus) (abfd, note))
b34976b6 7841 return TRUE;
bb0082d6 7842#if defined (HAVE_PRSTATUS_T)
252b5132 7843 return elfcore_grok_prstatus (abfd, note);
bb0082d6 7844#else
b34976b6 7845 return TRUE;
252b5132
RH		 7846#endif
7847
7848#if defined (HAVE_PSTATUS_T)
7849 case NT_PSTATUS:
7850 return elfcore_grok_pstatus (abfd, note);
7851#endif
7852
7853#if defined (HAVE_LWPSTATUS_T)
7854 case NT_LWPSTATUS:
7855 return elfcore_grok_lwpstatus (abfd, note);
7856#endif
7857
7858 case NT_FPREGSET: /* FIXME: rename to NT_PRFPREG */
7859 return elfcore_grok_prfpreg (abfd, note);
7860
16e9c715 7861#if defined (HAVE_WIN32_PSTATUS_T)
c044fabd 7862 case NT_WIN32PSTATUS:
16e9c715
NC		 7863 return elfcore_grok_win32pstatus (abfd, note);
7864#endif
7865
c044fabd 7866 case NT_PRXFPREG: /* Linux SSE extension */
e377ab71
MK		 7867 if (note->namesz == 6
7868 && strcmp (note->namedata, "LINUX") == 0)
ff08c6bb
JB		 7869 return elfcore_grok_prxfpreg (abfd, note);
7870 else
b34976b6 7871 return TRUE;
ff08c6bb 7872
252b5132
RH		 7873 case NT_PRPSINFO:
7874 case NT_PSINFO:
bb0082d6
AM		 7875 if (bed->elf_backend_grok_psinfo)
7876 if ((*bed->elf_backend_grok_psinfo) (abfd, note))
b34976b6 7877 return TRUE;
bb0082d6 7878#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
252b5132 7879 return elfcore_grok_psinfo (abfd, note);
bb0082d6 7880#else
b34976b6 7881 return TRUE;
252b5132 7882#endif
3333a7c3
RM		 7883
7884 case NT_AUXV:
7885 {
117ed4f8
AM		 7886 asection *sect = bfd_make_section_anyway_with_flags (abfd, ".auxv",
7887 SEC_HAS_CONTENTS);
3333a7c3
RM		 7888
7889 if (sect == NULL)
7890 return FALSE;
eea6121a 7891 sect->size = note->descsz;
3333a7c3 7892 sect->filepos = note->descpos;
3333a7c3
RM		 7893 sect->alignment_power = 1 + bfd_get_arch_size (abfd) / 32;
7894
7895 return TRUE;
7896 }
252b5132
RH		 7897 }
7898}
7899
b34976b6 7900static bfd_boolean
217aa764 7901elfcore_netbsd_get_lwpid (Elf_Internal_Note *note, int *lwpidp)
50b2bdb7
AM		 7902{
7903 char *cp;
7904
7905 cp = strchr (note->namedata, '@');
7906 if (cp != NULL)
7907 {
d2b64500 7908 *lwpidp = atoi(cp + 1);
b34976b6 7909 return TRUE;
50b2bdb7 7910 }
b34976b6 7911 return FALSE;
50b2bdb7
AM		 7912}
7913
b34976b6 7914static bfd_boolean
217aa764 7915elfcore_grok_netbsd_procinfo (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 7916{
7917
7918 /* Signal number at offset 0x08. */
7919 elf_tdata (abfd)->core_signal
7920 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x08);
7921
7922 /* Process ID at offset 0x50. */
7923 elf_tdata (abfd)->core_pid
7924 = bfd_h_get_32 (abfd, (bfd_byte *) note->descdata + 0x50);
7925
7926 /* Command name at 0x7c (max 32 bytes, including nul). */
7927 elf_tdata (abfd)->core_command
7928 = _bfd_elfcore_strndup (abfd, note->descdata + 0x7c, 31);
7929
7720ba9f
MK		 7930 return elfcore_make_note_pseudosection (abfd, ".note.netbsdcore.procinfo",
7931 note);
50b2bdb7
AM		 7932}
7933
b34976b6 7934static bfd_boolean
217aa764 7935elfcore_grok_netbsd_note (bfd *abfd, Elf_Internal_Note *note)
50b2bdb7
AM		 7936{
7937 int lwp;
7938
7939 if (elfcore_netbsd_get_lwpid (note, &lwp))
7940 elf_tdata (abfd)->core_lwpid = lwp;
7941
b4db1224 7942 if (note->type == NT_NETBSDCORE_PROCINFO)
50b2bdb7
AM		 7943 {
7944 /* NetBSD-specific core "procinfo". Note that we expect to
7945 find this note before any of the others, which is fine,
7946 since the kernel writes this note out first when it
7947 creates a core file. */
47d9a591 7948
50b2bdb7
AM		 7949 return elfcore_grok_netbsd_procinfo (abfd, note);
7950 }
7951
b4db1224
JT		 7952 /* As of Jan 2002 there are no other machine-independent notes
7953 defined for NetBSD core files. If the note type is less
7954 than the start of the machine-dependent note types, we don't
7955 understand it. */
47d9a591 7956
b4db1224 7957 if (note->type < NT_NETBSDCORE_FIRSTMACH)
b34976b6 7958 return TRUE;
50b2bdb7
AM		 7959
7960
7961 switch (bfd_get_arch (abfd))
7962 {
7963 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0 and
7964 PT_GETFPREGS == mach+2. */
7965
7966 case bfd_arch_alpha:
7967 case bfd_arch_sparc:
7968 switch (note->type)
7969 {
b4db1224 7970 case NT_NETBSDCORE_FIRSTMACH+0:
50b2bdb7
AM		 7971 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7972
b4db1224 7973 case NT_NETBSDCORE_FIRSTMACH+2:
50b2bdb7
AM		 7974 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7975
7976 default:
b34976b6 7977 return TRUE;
50b2bdb7
AM		 7978 }
7979
7980 /* On all other arch's, PT_GETREGS == mach+1 and
7981 PT_GETFPREGS == mach+3. */
7982
7983 default:
7984 switch (note->type)
7985 {
b4db1224 7986 case NT_NETBSDCORE_FIRSTMACH+1:
50b2bdb7
AM		 7987 return elfcore_make_note_pseudosection (abfd, ".reg", note);
7988
b4db1224 7989 case NT_NETBSDCORE_FIRSTMACH+3:
50b2bdb7
AM		 7990 return elfcore_make_note_pseudosection (abfd, ".reg2", note);
7991
7992 default:
b34976b6 7993 return TRUE;
50b2bdb7
AM		 7994 }
7995 }
7996 /* NOTREACHED */
7997}
7998
07c6e936 7999static bfd_boolean
d3fd4074 8000elfcore_grok_nto_status (bfd *abfd, Elf_Internal_Note *note, long *tid)
07c6e936
NC		 8001{
8002 void *ddata = note->descdata;
8003 char buf[100];
8004 char *name;
8005 asection *sect;
f8843e87
AM		 8006 short sig;
8007 unsigned flags;
07c6e936
NC		 8008
8009 /* nto_procfs_status 'pid' field is at offset 0. */
8010 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, (bfd_byte *) ddata);
8011
f8843e87
AM		 8012 /* nto_procfs_status 'tid' field is at offset 4. Pass it back. */
8013 *tid = bfd_get_32 (abfd, (bfd_byte *) ddata + 4);
8014
8015 /* nto_procfs_status 'flags' field is at offset 8. */
8016 flags = bfd_get_32 (abfd, (bfd_byte *) ddata + 8);
07c6e936
NC		 8017
8018 /* nto_procfs_status 'what' field is at offset 14. */
f8843e87
AM		 8019 if ((sig = bfd_get_16 (abfd, (bfd_byte *) ddata + 14)) > 0)
8020 {
8021 elf_tdata (abfd)->core_signal = sig;
8022 elf_tdata (abfd)->core_lwpid = *tid;
8023 }
07c6e936 8024
f8843e87
AM		 8025 /* _DEBUG_FLAG_CURTID (current thread) is 0x80. Some cores
8026 do not come from signals so we make sure we set the current
8027 thread just in case. */
8028 if (flags & 0x00000080)
8029 elf_tdata (abfd)->core_lwpid = *tid;
07c6e936
NC		 8030
8031 /* Make a ".qnx_core_status/%d" section. */
d3fd4074 8032 sprintf (buf, ".qnx_core_status/%ld", *tid);
07c6e936 8033
217aa764 8034 name = bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 8035 if (name == NULL)
8036 return FALSE;
8037 strcpy (name, buf);
8038
117ed4f8 8039 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 8040 if (sect == NULL)
8041 return FALSE;
8042
eea6121a 8043 sect->size = note->descsz;
07c6e936 8044 sect->filepos = note->descpos;
07c6e936
NC		 8045 sect->alignment_power = 2;
8046
8047 return (elfcore_maybe_make_sect (abfd, ".qnx_core_status", sect));
8048}
8049
8050static bfd_boolean
d69f560c
KW		 8051elfcore_grok_nto_regs (bfd *abfd,
8052 Elf_Internal_Note *note,
d3fd4074 8053 long tid,
d69f560c 8054 char *base)
07c6e936
NC		 8055{
8056 char buf[100];
8057 char *name;
8058 asection *sect;
8059
d69f560c 8060 /* Make a "(base)/%d" section. */
d3fd4074 8061 sprintf (buf, "%s/%ld", base, tid);
07c6e936 8062
217aa764 8063 name = bfd_alloc (abfd, strlen (buf) + 1);
07c6e936
NC		 8064 if (name == NULL)
8065 return FALSE;
8066 strcpy (name, buf);
8067
117ed4f8 8068 sect = bfd_make_section_anyway_with_flags (abfd, name, SEC_HAS_CONTENTS);
07c6e936
NC		 8069 if (sect == NULL)
8070 return FALSE;
8071
eea6121a 8072 sect->size = note->descsz;
07c6e936 8073 sect->filepos = note->descpos;
07c6e936
NC		 8074 sect->alignment_power = 2;
8075
f8843e87
AM		 8076 /* This is the current thread. */
8077 if (elf_tdata (abfd)->core_lwpid == tid)
d69f560c 8078 return elfcore_maybe_make_sect (abfd, base, sect);
f8843e87
AM		 8079
8080 return TRUE;
07c6e936
NC		 8081}
8082
8083#define BFD_QNT_CORE_INFO 7
8084#define BFD_QNT_CORE_STATUS 8
8085#define BFD_QNT_CORE_GREG 9
8086#define BFD_QNT_CORE_FPREG 10
8087
8088static bfd_boolean
217aa764 8089elfcore_grok_nto_note (bfd *abfd, Elf_Internal_Note *note)
07c6e936
NC		 8090{
8091 /* Every GREG section has a STATUS section before it. Store the
811072d8 8092 tid from the previous call to pass down to the next gregs
07c6e936 8093 function. */
d3fd4074 8094 static long tid = 1;
07c6e936
NC		 8095
8096 switch (note->type)
8097 {
d69f560c
KW		 8098 case BFD_QNT_CORE_INFO:
8099 return elfcore_make_note_pseudosection (abfd, ".qnx_core_info", note);
8100 case BFD_QNT_CORE_STATUS:
8101 return elfcore_grok_nto_status (abfd, note, &tid);
8102 case BFD_QNT_CORE_GREG:
8103 return elfcore_grok_nto_regs (abfd, note, tid, ".reg");
8104 case BFD_QNT_CORE_FPREG:
8105 return elfcore_grok_nto_regs (abfd, note, tid, ".reg2");
8106 default:
8107 return TRUE;
07c6e936
NC		 8108 }
8109}
8110
7c76fa91
MS		 8111/* Function: elfcore_write_note
8112
47d9a591 8113 Inputs:
a39f3346 8114 buffer to hold note, and current size of buffer
7c76fa91
MS		 8115 name of note
8116 type of note
8117 data for note
8118 size of data for note
8119
a39f3346
AM		 8120 Writes note to end of buffer. ELF64 notes are written exactly as
8121 for ELF32, despite the current (as of 2006) ELF gabi specifying
8122 that they ought to have 8-byte namesz and descsz field, and have
8123 8-byte alignment. Other writers, eg. Linux kernel, do the same.
8124
7c76fa91 8125 Return:
a39f3346 8126 Pointer to realloc'd buffer, *BUFSIZ updated. */
7c76fa91
MS		 8127
8128char *
a39f3346 8129elfcore_write_note (bfd *abfd,
217aa764 8130 char *buf,
a39f3346 8131 int *bufsiz,
217aa764 8132 const char *name,
a39f3346 8133 int type,
217aa764 8134 const void *input,
a39f3346 8135 int size)
7c76fa91
MS		 8136{
8137 Elf_External_Note *xnp;
d4c88bbb 8138 size_t namesz;
d4c88bbb 8139 size_t newspace;
a39f3346 8140 char *dest;
7c76fa91 8141
d4c88bbb 8142 namesz = 0;
d4c88bbb 8143 if (name != NULL)
a39f3346 8144 namesz = strlen (name) + 1;
d4c88bbb 8145
a39f3346 8146 newspace = 12 + ((namesz + 3) & -4) + ((size + 3) & -4);
d4c88bbb 8147
a39f3346
AM		 8148 buf = realloc (buf, *bufsiz + newspace);
8149 dest = buf + *bufsiz;
7c76fa91
MS		 8150 *bufsiz += newspace;
8151 xnp = (Elf_External_Note *) dest;
8152 H_PUT_32 (abfd, namesz, xnp->namesz);
8153 H_PUT_32 (abfd, size, xnp->descsz);
8154 H_PUT_32 (abfd, type, xnp->type);
d4c88bbb
AM		 8155 dest = xnp->name;
8156 if (name != NULL)
8157 {
8158 memcpy (dest, name, namesz);
8159 dest += namesz;
a39f3346 8160 while (namesz & 3)
d4c88bbb
AM		 8161 {
8162 *dest++ = '\0';
a39f3346 8163 ++namesz;
d4c88bbb
AM		 8164 }
8165 }
8166 memcpy (dest, input, size);
a39f3346
AM		 8167 dest += size;
8168 while (size & 3)
8169 {
8170 *dest++ = '\0';
8171 ++size;
8172 }
8173 return buf;
7c76fa91
MS		 8174}
8175
8176#if defined (HAVE_PRPSINFO_T) || defined (HAVE_PSINFO_T)
8177char *
217aa764
AM		 8178elfcore_write_prpsinfo (bfd *abfd,
8179 char *buf,
8180 int *bufsiz,
8181 const char *fname,
8182 const char *psargs)
7c76fa91
MS		 8183{
8184 int note_type;
8185 char *note_name = "CORE";
8186
8187#if defined (HAVE_PSINFO_T)
8188 psinfo_t data;
8189 note_type = NT_PSINFO;
8190#else
8191 prpsinfo_t data;
8192 note_type = NT_PRPSINFO;
8193#endif
8194
8195 memset (&data, 0, sizeof (data));
8196 strncpy (data.pr_fname, fname, sizeof (data.pr_fname));
8197 strncpy (data.pr_psargs, psargs, sizeof (data.pr_psargs));
47d9a591 8198 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 8199 note_name, note_type, &data, sizeof (data));
8200}
8201#endif /* PSINFO_T or PRPSINFO_T */
8202
8203#if defined (HAVE_PRSTATUS_T)
8204char *
217aa764
AM		 8205elfcore_write_prstatus (bfd *abfd,
8206 char *buf,
8207 int *bufsiz,
8208 long pid,
8209 int cursig,
8210 const void *gregs)
7c76fa91
MS		 8211{
8212 prstatus_t prstat;
8213 char *note_name = "CORE";
8214
8215 memset (&prstat, 0, sizeof (prstat));
8216 prstat.pr_pid = pid;
8217 prstat.pr_cursig = cursig;
c106e334 8218 memcpy (&prstat.pr_reg, gregs, sizeof (prstat.pr_reg));
47d9a591 8219 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 8220 note_name, NT_PRSTATUS, &prstat, sizeof (prstat));
8221}
8222#endif /* HAVE_PRSTATUS_T */
8223
51316059
MS		 8224#if defined (HAVE_LWPSTATUS_T)
8225char *
217aa764
AM		 8226elfcore_write_lwpstatus (bfd *abfd,
8227 char *buf,
8228 int *bufsiz,
8229 long pid,
8230 int cursig,
8231 const void *gregs)
51316059
MS		 8232{
8233 lwpstatus_t lwpstat;
8234 char *note_name = "CORE";
8235
8236 memset (&lwpstat, 0, sizeof (lwpstat));
8237 lwpstat.pr_lwpid = pid >> 16;
8238 lwpstat.pr_cursig = cursig;
8239#if defined (HAVE_LWPSTATUS_T_PR_REG)
8240 memcpy (lwpstat.pr_reg, gregs, sizeof (lwpstat.pr_reg));
8241#elif defined (HAVE_LWPSTATUS_T_PR_CONTEXT)
8242#if !defined(gregs)
8243 memcpy (lwpstat.pr_context.uc_mcontext.gregs,
8244 gregs, sizeof (lwpstat.pr_context.uc_mcontext.gregs));
8245#else
8246 memcpy (lwpstat.pr_context.uc_mcontext.__gregs,
8247 gregs, sizeof (lwpstat.pr_context.uc_mcontext.__gregs));
8248#endif
8249#endif
47d9a591 8250 return elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 8251 NT_LWPSTATUS, &lwpstat, sizeof (lwpstat));
8252}
8253#endif /* HAVE_LWPSTATUS_T */
8254
7c76fa91
MS		 8255#if defined (HAVE_PSTATUS_T)
8256char *
217aa764
AM		 8257elfcore_write_pstatus (bfd *abfd,
8258 char *buf,
8259 int *bufsiz,
8260 long pid,
6c10990d
NC		 8261 int cursig ATTRIBUTE_UNUSED,
8262 const void *gregs ATTRIBUTE_UNUSED)
7c76fa91
MS		 8263{
8264 pstatus_t pstat;
8265 char *note_name = "CORE";
8266
51316059
MS		 8267 memset (&pstat, 0, sizeof (pstat));
8268 pstat.pr_pid = pid & 0xffff;
47d9a591 8269 buf = elfcore_write_note (abfd, buf, bufsiz, note_name,
51316059
MS		 8270 NT_PSTATUS, &pstat, sizeof (pstat));
8271 return buf;
7c76fa91
MS		 8272}
8273#endif /* HAVE_PSTATUS_T */
8274
8275char *
217aa764
AM		 8276elfcore_write_prfpreg (bfd *abfd,
8277 char *buf,
8278 int *bufsiz,
8279 const void *fpregs,
8280 int size)
7c76fa91
MS		 8281{
8282 char *note_name = "CORE";
47d9a591 8283 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 8284 note_name, NT_FPREGSET, fpregs, size);
8285}
8286
8287char *
217aa764
AM		 8288elfcore_write_prxfpreg (bfd *abfd,
8289 char *buf,
8290 int *bufsiz,
8291 const void *xfpregs,
8292 int size)
7c76fa91
MS		 8293{
8294 char *note_name = "LINUX";
47d9a591 8295 return elfcore_write_note (abfd, buf, bufsiz,
7c76fa91
MS		 8296 note_name, NT_PRXFPREG, xfpregs, size);
8297}
8298
b34976b6 8299static bfd_boolean
217aa764 8300elfcore_read_notes (bfd *abfd, file_ptr offset, bfd_size_type size)
252b5132 8301{
c044fabd
KH		 8302 char *buf;
8303 char *p;
252b5132
RH		 8304
8305 if (size <= 0)
b34976b6 8306 return TRUE;
252b5132 8307
dc810e39 8308 if (bfd_seek (abfd, offset, SEEK_SET) != 0)
b34976b6 8309 return FALSE;
252b5132 8310
dc810e39 8311 buf = bfd_malloc (size);
252b5132 8312 if (buf == NULL)
b34976b6 8313 return FALSE;
252b5132 8314
dc810e39 8315 if (bfd_bread (buf, size, abfd) != size)
252b5132
RH		 8316 {
8317 error:
8318 free (buf);
b34976b6 8319 return FALSE;
252b5132
RH		 8320 }
8321
8322 p = buf;
8323 while (p < buf + size)
8324 {
c044fabd
KH		 8325 /* FIXME: bad alignment assumption. */
8326 Elf_External_Note *xnp = (Elf_External_Note *) p;
252b5132
RH		 8327 Elf_Internal_Note in;
8328
dc810e39 8329 in.type = H_GET_32 (abfd, xnp->type);
252b5132 8330
dc810e39 8331 in.namesz = H_GET_32 (abfd, xnp->namesz);
252b5132
RH		 8332 in.namedata = xnp->name;
8333
dc810e39 8334 in.descsz = H_GET_32 (abfd, xnp->descsz);
252b5132
RH		 8335 in.descdata = in.namedata + BFD_ALIGN (in.namesz, 4);
8336 in.descpos = offset + (in.descdata - buf);
8337
0112cd26 8338 if (CONST_STRNEQ (in.namedata, "NetBSD-CORE"))
50b2bdb7
AM		 8339 {
8340 if (! elfcore_grok_netbsd_note (abfd, &in))
8341 goto error;
8342 }
0112cd26 8343 else if (CONST_STRNEQ (in.namedata, "QNX"))
07c6e936
NC		 8344 {
8345 if (! elfcore_grok_nto_note (abfd, &in))
8346 goto error;
8347 }
50b2bdb7
AM		 8348 else
8349 {
8350 if (! elfcore_grok_note (abfd, &in))
8351 goto error;
8352 }
252b5132
RH		 8353
8354 p = in.descdata + BFD_ALIGN (in.descsz, 4);
8355 }
8356
8357 free (buf);
b34976b6 8358 return TRUE;
252b5132 8359}
98d8431c
JB		 8360\f
8361/* Providing external access to the ELF program header table. */
8362
8363/* Return an upper bound on the number of bytes required to store a
8364 copy of ABFD's program header table entries. Return -1 if an error
8365 occurs; bfd_get_error will return an appropriate code. */
c044fabd 8366
98d8431c 8367long
217aa764 8368bfd_get_elf_phdr_upper_bound (bfd *abfd)
98d8431c
JB		 8369{
8370 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8371 {
8372 bfd_set_error (bfd_error_wrong_format);
8373 return -1;
8374 }
8375
936e320b 8376 return elf_elfheader (abfd)->e_phnum * sizeof (Elf_Internal_Phdr);
98d8431c
JB		 8377}
8378
98d8431c
JB		 8379/* Copy ABFD's program header table entries to *PHDRS. The entries
8380 will be stored as an array of Elf_Internal_Phdr structures, as
8381 defined in include/elf/internal.h. To find out how large the
8382 buffer needs to be, call bfd_get_elf_phdr_upper_bound.
8383
8384 Return the number of program header table entries read, or -1 if an
8385 error occurs; bfd_get_error will return an appropriate code. */
c044fabd 8386
98d8431c 8387int
217aa764 8388bfd_get_elf_phdrs (bfd *abfd, void *phdrs)
98d8431c
JB		 8389{
8390 int num_phdrs;
8391
8392 if (abfd->xvec->flavour != bfd_target_elf_flavour)
8393 {
8394 bfd_set_error (bfd_error_wrong_format);
8395 return -1;
8396 }
8397
8398 num_phdrs = elf_elfheader (abfd)->e_phnum;
c044fabd 8399 memcpy (phdrs, elf_tdata (abfd)->phdr,
98d8431c
JB		 8400 num_phdrs * sizeof (Elf_Internal_Phdr));
8401
8402 return num_phdrs;
8403}
ae4221d7
L		 8404
8405void
217aa764 8406_bfd_elf_sprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, char *buf, bfd_vma value)
ae4221d7 8407{
d3b05f8d 8408#ifdef BFD64
ae4221d7
L		 8409 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
8410
8411 i_ehdrp = elf_elfheader (abfd);
8412 if (i_ehdrp == NULL)
8413 sprintf_vma (buf, value);
8414 else
8415 {
8416 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
cc55aec9 8417 {
ae4221d7 8418#if BFD_HOST_64BIT_LONG
cc55aec9 8419 sprintf (buf, "%016lx", value);
ae4221d7 8420#else
cc55aec9
AM		 8421 sprintf (buf, "%08lx%08lx", _bfd_int64_high (value),
8422 _bfd_int64_low (value));
ae4221d7 8423#endif
cc55aec9 8424 }
ae4221d7
L		 8425 else
8426 sprintf (buf, "%08lx", (unsigned long) (value & 0xffffffff));
8427 }
d3b05f8d
L		 8428#else
8429 sprintf_vma (buf, value);
8430#endif
ae4221d7
L		 8431}
8432
8433void
217aa764 8434_bfd_elf_fprintf_vma (bfd *abfd ATTRIBUTE_UNUSED, void *stream, bfd_vma value)
ae4221d7 8435{
d3b05f8d 8436#ifdef BFD64
ae4221d7
L		 8437 Elf_Internal_Ehdr *i_ehdrp; /* Elf file header, internal form */
8438
8439 i_ehdrp = elf_elfheader (abfd);
8440 if (i_ehdrp == NULL)
8441 fprintf_vma ((FILE *) stream, value);
8442 else
8443 {
8444 if (i_ehdrp->e_ident[EI_CLASS] == ELFCLASS64)
cc55aec9 8445 {
ae4221d7 8446#if BFD_HOST_64BIT_LONG
cc55aec9 8447 fprintf ((FILE *) stream, "%016lx", value);
ae4221d7 8448#else
cc55aec9
AM		 8449 fprintf ((FILE *) stream, "%08lx%08lx",
8450 _bfd_int64_high (value), _bfd_int64_low (value));
ae4221d7 8451#endif
cc55aec9 8452 }
ae4221d7
L		 8453 else
8454 fprintf ((FILE *) stream, "%08lx",
8455 (unsigned long) (value & 0xffffffff));
8456 }
d3b05f8d
L		 8457#else
8458 fprintf_vma ((FILE *) stream, value);
8459#endif
ae4221d7 8460}
db6751f2
JJ		 8461
8462enum elf_reloc_type_class
217aa764 8463_bfd_elf_reloc_type_class (const Elf_Internal_Rela *rela ATTRIBUTE_UNUSED)
db6751f2
JJ		 8464{
8465 return reloc_class_normal;
8466}
f8df10f4 8467
47d9a591 8468/* For RELA architectures, return the relocation value for a
f8df10f4
JJ		 8469 relocation against a local symbol. */
8470
8471bfd_vma
217aa764
AM		 8472_bfd_elf_rela_local_sym (bfd *abfd,
8473 Elf_Internal_Sym *sym,
8517fae7 8474 asection **psec,
217aa764 8475 Elf_Internal_Rela *rel)
f8df10f4 8476{
8517fae7 8477 asection *sec = *psec;
f8df10f4
JJ		 8478 bfd_vma relocation;
8479
8480 relocation = (sec->output_section->vma
8481 + sec->output_offset
8482 + sym->st_value);
8483 if ((sec->flags & SEC_MERGE)
c629eae0 8484 && ELF_ST_TYPE (sym->st_info) == STT_SECTION
68bfbfcc 8485 && sec->sec_info_type == ELF_INFO_TYPE_MERGE)
f8df10f4 8486 {
f8df10f4 8487 rel->r_addend =
8517fae7 8488 _bfd_merged_section_offset (abfd, psec,
65765700 8489 elf_section_data (sec)->sec_info,
753731ee
AM		 8490 sym->st_value + rel->r_addend);
8491 if (sec != *psec)
8492 {
8493 /* If we have changed the section, and our original section is
8494 marked with SEC_EXCLUDE, it means that the original
8495 SEC_MERGE section has been completely subsumed in some
8496 other SEC_MERGE section. In this case, we need to leave
8497 some info around for --emit-relocs. */
8498 if ((sec->flags & SEC_EXCLUDE) != 0)
8499 sec->kept_section = *psec;
8500 sec = *psec;
8501 }
8517fae7
AM		 8502 rel->r_addend -= relocation;
8503 rel->r_addend += sec->output_section->vma + sec->output_offset;
f8df10f4
JJ		 8504 }
8505 return relocation;
8506}
c629eae0
JJ		 8507
8508bfd_vma
217aa764
AM		 8509_bfd_elf_rel_local_sym (bfd *abfd,
8510 Elf_Internal_Sym *sym,
8511 asection **psec,
8512 bfd_vma addend)
47d9a591 8513{
c629eae0
JJ		 8514 asection *sec = *psec;
8515
68bfbfcc 8516 if (sec->sec_info_type != ELF_INFO_TYPE_MERGE)
c629eae0
JJ		 8517 return sym->st_value + addend;
8518
8519 return _bfd_merged_section_offset (abfd, psec,
65765700 8520 elf_section_data (sec)->sec_info,
753731ee 8521 sym->st_value + addend);
c629eae0
JJ		 8522}
8523
8524bfd_vma
217aa764 8525_bfd_elf_section_offset (bfd *abfd,
92e4ec35 8526 struct bfd_link_info *info,
217aa764
AM		 8527 asection *sec,
8528 bfd_vma offset)
c629eae0 8529{
68bfbfcc 8530 switch (sec->sec_info_type)
65765700
JJ		 8531 {
8532 case ELF_INFO_TYPE_STABS:
eea6121a
AM		 8533 return _bfd_stab_section_offset (sec, elf_section_data (sec)->sec_info,
8534 offset);
65765700 8535 case ELF_INFO_TYPE_EH_FRAME:
92e4ec35 8536 return _bfd_elf_eh_frame_section_offset (abfd, info, sec, offset);
65765700
JJ		 8537 default:
8538 return offset;
8539 }
c629eae0 8540}
3333a7c3
RM		 8541\f
8542/* Create a new BFD as if by bfd_openr. Rather than opening a file,
8543 reconstruct an ELF file by reading the segments out of remote memory
8544 based on the ELF file header at EHDR_VMA and the ELF program headers it
8545 points to. If not null, *LOADBASEP is filled in with the difference
8546 between the VMAs from which the segments were read, and the VMAs the
8547 file headers (and hence BFD's idea of each section's VMA) put them at.
8548
8549 The function TARGET_READ_MEMORY is called to copy LEN bytes from the
8550 remote memory at target address VMA into the local buffer at MYADDR; it
8551 should return zero on success or an `errno' code on failure. TEMPL must
8552 be a BFD for an ELF target with the word size and byte order found in
8553 the remote memory. */
8554
8555bfd *
217aa764
AM		 8556bfd_elf_bfd_from_remote_memory
8557 (bfd *templ,
8558 bfd_vma ehdr_vma,
8559 bfd_vma *loadbasep,
f075ee0c 8560 int (*target_read_memory) (bfd_vma, bfd_byte *, int))
3333a7c3
RM		 8561{
8562 return (*get_elf_backend_data (templ)->elf_backend_bfd_from_remote_memory)
8563 (templ, ehdr_vma, loadbasep, target_read_memory);
8564}
4c45e5c9
JJ		 8565\f
8566long
c9727e01
AM		 8567_bfd_elf_get_synthetic_symtab (bfd *abfd,
8568 long symcount ATTRIBUTE_UNUSED,
8569 asymbol **syms ATTRIBUTE_UNUSED,
8615f3f2 8570 long dynsymcount,
c9727e01
AM		 8571 asymbol **dynsyms,
8572 asymbol **ret)
4c45e5c9
JJ		 8573{
8574 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
8575 asection *relplt;
8576 asymbol *s;
8577 const char *relplt_name;
8578 bfd_boolean (*slurp_relocs) (bfd *, asection *, asymbol **, bfd_boolean);
8579 arelent *p;
8580 long count, i, n;
8581 size_t size;
8582 Elf_Internal_Shdr *hdr;
8583 char *names;
8584 asection *plt;
8585
8615f3f2
AM		 8586 *ret = NULL;
8587
90e3cdf2
JJ		 8588 if ((abfd->flags & (DYNAMIC | EXEC_P)) == 0)
8589 return 0;
8590
8615f3f2
AM		 8591 if (dynsymcount <= 0)
8592 return 0;
8593
4c45e5c9
JJ		 8594 if (!bed->plt_sym_val)
8595 return 0;
8596
8597 relplt_name = bed->relplt_name;
8598 if (relplt_name == NULL)
8599 relplt_name = bed->default_use_rela_p ? ".rela.plt" : ".rel.plt";
8600 relplt = bfd_get_section_by_name (abfd, relplt_name);
8601 if (relplt == NULL)
8602 return 0;
8603
8604 hdr = &elf_section_data (relplt)->this_hdr;
8605 if (hdr->sh_link != elf_dynsymtab (abfd)
8606 || (hdr->sh_type != SHT_REL && hdr->sh_type != SHT_RELA))
8607 return 0;
8608
8609 plt = bfd_get_section_by_name (abfd, ".plt");
8610 if (plt == NULL)
8611 return 0;
8612
8613 slurp_relocs = get_elf_backend_data (abfd)->s->slurp_reloc_table;
c9727e01 8614 if (! (*slurp_relocs) (abfd, relplt, dynsyms, TRUE))
4c45e5c9
JJ		 8615 return -1;
8616
eea6121a 8617 count = relplt->size / hdr->sh_entsize;
4c45e5c9
JJ		 8618 size = count * sizeof (asymbol);
8619 p = relplt->relocation;
8620 for (i = 0; i < count; i++, s++, p++)
8621 size += strlen ((*p->sym_ptr_ptr)->name) + sizeof ("@plt");
8622
8623 s = *ret = bfd_malloc (size);
8624 if (s == NULL)
8625 return -1;
8626
8627 names = (char *) (s + count);
8628 p = relplt->relocation;
8629 n = 0;
8630 for (i = 0; i < count; i++, s++, p++)
8631 {
8632 size_t len;
8633 bfd_vma addr;
8634
8635 addr = bed->plt_sym_val (i, plt, p);
8636 if (addr == (bfd_vma) -1)
8637 continue;
8638
8639 *s = **p->sym_ptr_ptr;
65a7a66f
AM		 8640 /* Undefined syms won't have BSF_LOCAL or BSF_GLOBAL set. Since
8641 we are defining a symbol, ensure one of them is set. */
8642 if ((s->flags & BSF_LOCAL) == 0)
8643 s->flags |= BSF_GLOBAL;
4c45e5c9
JJ		 8644 s->section = plt;
8645 s->value = addr - plt->vma;
8646 s->name = names;
8647 len = strlen ((*p->sym_ptr_ptr)->name);
8648 memcpy (names, (*p->sym_ptr_ptr)->name, len);
8649 names += len;
8650 memcpy (names, "@plt", sizeof ("@plt"));
8651 names += sizeof ("@plt");
8652 ++n;
8653 }
8654
8655 return n;
8656}
3d7f7666
L		 8657
8658/* Sort symbol by binding and section. We want to put definitions
8659 sorted by section at the beginning. */
8660
8661static int
8662elf_sort_elf_symbol (const void *arg1, const void *arg2)
8663{
8664 const Elf_Internal_Sym *s1;
8665 const Elf_Internal_Sym *s2;
8666 int shndx;
8667
8668 /* Make sure that undefined symbols are at the end. */
8669 s1 = (const Elf_Internal_Sym *) arg1;
8670 if (s1->st_shndx == SHN_UNDEF)
8671 return 1;
8672 s2 = (const Elf_Internal_Sym *) arg2;
8673 if (s2->st_shndx == SHN_UNDEF)
8674 return -1;
8675
8676 /* Sorted by section index. */
8677 shndx = s1->st_shndx - s2->st_shndx;
8678 if (shndx != 0)
8679 return shndx;
8680
8681 /* Sorted by binding. */
8682 return ELF_ST_BIND (s1->st_info) - ELF_ST_BIND (s2->st_info);
8683}
8684
8685struct elf_symbol
8686{
8687 Elf_Internal_Sym *sym;
8688 const char *name;
8689};
8690
8691static int
8692elf_sym_name_compare (const void *arg1, const void *arg2)
8693{
8694 const struct elf_symbol *s1 = (const struct elf_symbol *) arg1;
8695 const struct elf_symbol *s2 = (const struct elf_symbol *) arg2;
8696 return strcmp (s1->name, s2->name);
8697}
8698
8699/* Check if 2 sections define the same set of local and global
8700 symbols. */
8701
8702bfd_boolean
c0f00686
L		 8703bfd_elf_match_symbols_in_sections (asection *sec1, asection *sec2,
8704 struct bfd_link_info *info)
3d7f7666
L		 8705{
8706 bfd *bfd1, *bfd2;
8707 const struct elf_backend_data *bed1, *bed2;
8708 Elf_Internal_Shdr *hdr1, *hdr2;
8709 bfd_size_type symcount1, symcount2;
8710 Elf_Internal_Sym *isymbuf1, *isymbuf2;
8711 Elf_Internal_Sym *isymstart1 = NULL, *isymstart2 = NULL, *isym;
8712 Elf_Internal_Sym *isymend;
8713 struct elf_symbol *symp, *symtable1 = NULL, *symtable2 = NULL;
8714 bfd_size_type count1, count2, i;
8715 int shndx1, shndx2;
8716 bfd_boolean result;
8717
8718 bfd1 = sec1->owner;
8719 bfd2 = sec2->owner;
8720
8721 /* If both are .gnu.linkonce sections, they have to have the same
8722 section name. */
0112cd26
NC		 8723 if (CONST_STRNEQ (sec1->name, ".gnu.linkonce")
8724 && CONST_STRNEQ (sec2->name, ".gnu.linkonce"))
3d7f7666
L		 8725 return strcmp (sec1->name + sizeof ".gnu.linkonce",
8726 sec2->name + sizeof ".gnu.linkonce") == 0;
8727
8728 /* Both sections have to be in ELF. */
8729 if (bfd_get_flavour (bfd1) != bfd_target_elf_flavour
8730 || bfd_get_flavour (bfd2) != bfd_target_elf_flavour)
8731 return FALSE;
8732
8733 if (elf_section_type (sec1) != elf_section_type (sec2))
8734 return FALSE;
8735
8736 if ((elf_section_flags (sec1) & SHF_GROUP) != 0
8737 && (elf_section_flags (sec2) & SHF_GROUP) != 0)
8738 {
8739 /* If both are members of section groups, they have to have the
8740 same group name. */
8741 if (strcmp (elf_group_name (sec1), elf_group_name (sec2)) != 0)
8742 return FALSE;
8743 }
8744
8745 shndx1 = _bfd_elf_section_from_bfd_section (bfd1, sec1);
8746 shndx2 = _bfd_elf_section_from_bfd_section (bfd2, sec2);
8747 if (shndx1 == -1 || shndx2 == -1)
8748 return FALSE;
8749
8750 bed1 = get_elf_backend_data (bfd1);
8751 bed2 = get_elf_backend_data (bfd2);
8752 hdr1 = &elf_tdata (bfd1)->symtab_hdr;
8753 symcount1 = hdr1->sh_size / bed1->s->sizeof_sym;
8754 hdr2 = &elf_tdata (bfd2)->symtab_hdr;
8755 symcount2 = hdr2->sh_size / bed2->s->sizeof_sym;
8756
8757 if (symcount1 == 0 || symcount2 == 0)
8758 return FALSE;
8759
3d7f7666 8760 result = FALSE;
c0f00686
L		 8761 isymbuf1 = elf_tdata (bfd1)->symbuf;
8762 isymbuf2 = elf_tdata (bfd2)->symbuf;
3d7f7666 8763
c0f00686
L		 8764 if (isymbuf1 == NULL)
8765 {
8766 isymbuf1 = bfd_elf_get_elf_syms (bfd1, hdr1, symcount1, 0,
8767 NULL, NULL, NULL);
8768 if (isymbuf1 == NULL)
8769 goto done;
8770 /* Sort symbols by binding and section. Global definitions are at
8771 the beginning. */
8772 qsort (isymbuf1, symcount1, sizeof (Elf_Internal_Sym),
8773 elf_sort_elf_symbol);
8774 if (!info->reduce_memory_overheads)
8775 elf_tdata (bfd1)->symbuf = isymbuf1;
8776 }
8777
8778 if (isymbuf2 == NULL)
8779 {
8780 isymbuf2 = bfd_elf_get_elf_syms (bfd2, hdr2, symcount2, 0,
8781 NULL, NULL, NULL);
8782 if (isymbuf2 == NULL)
8783 goto done;
8784 /* Sort symbols by binding and section. Global definitions are at
8785 the beginning. */
8786 qsort (isymbuf2, symcount2, sizeof (Elf_Internal_Sym),
8787 elf_sort_elf_symbol);
8788 if (!info->reduce_memory_overheads)
8789 elf_tdata (bfd2)->symbuf = isymbuf2;
8790 }
3d7f7666
L		 8791
8792 /* Count definitions in the section. */
8793 count1 = 0;
8794 for (isym = isymbuf1, isymend = isym + symcount1;
8795 isym < isymend; isym++)
8796 {
8797 if (isym->st_shndx == (unsigned int) shndx1)
8798 {
8799 if (count1 == 0)
8800 isymstart1 = isym;
8801 count1++;
8802 }
8803
8804 if (count1 && isym->st_shndx != (unsigned int) shndx1)
8805 break;
8806 }
8807
8808 count2 = 0;
8809 for (isym = isymbuf2, isymend = isym + symcount2;
8810 isym < isymend; isym++)
8811 {
8812 if (isym->st_shndx == (unsigned int) shndx2)
8813 {
8814 if (count2 == 0)
8815 isymstart2 = isym;
8816 count2++;
8817 }
8818
8819 if (count2 && isym->st_shndx != (unsigned int) shndx2)
8820 break;
8821 }
8822
8823 if (count1 == 0 || count2 == 0 || count1 != count2)
8824 goto done;
8825
8826 symtable1 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8827 symtable2 = bfd_malloc (count1 * sizeof (struct elf_symbol));
8828
8829 if (symtable1 == NULL || symtable2 == NULL)
8830 goto done;
8831
8832 symp = symtable1;
8833 for (isym = isymstart1, isymend = isym + count1;
8834 isym < isymend; isym++)
8835 {
8836 symp->sym = isym;
8837 symp->name = bfd_elf_string_from_elf_section (bfd1,
8838 hdr1->sh_link,
8839 isym->st_name);
8840 symp++;
8841 }
8842
8843 symp = symtable2;
8844 for (isym = isymstart2, isymend = isym + count1;
8845 isym < isymend; isym++)
8846 {
8847 symp->sym = isym;
8848 symp->name = bfd_elf_string_from_elf_section (bfd2,
8849 hdr2->sh_link,
8850 isym->st_name);
8851 symp++;
8852 }
8853
8854 /* Sort symbol by name. */
8855 qsort (symtable1, count1, sizeof (struct elf_symbol),
8856 elf_sym_name_compare);
8857 qsort (symtable2, count1, sizeof (struct elf_symbol),
8858 elf_sym_name_compare);
8859
8860 for (i = 0; i < count1; i++)
8861 /* Two symbols must have the same binding, type and name. */
8862 if (symtable1 [i].sym->st_info != symtable2 [i].sym->st_info
8863 || symtable1 [i].sym->st_other != symtable2 [i].sym->st_other
8864 || strcmp (symtable1 [i].name, symtable2 [i].name) != 0)
8865 goto done;
8866
8867 result = TRUE;
8868
8869done:
8870 if (symtable1)
8871 free (symtable1);
8872 if (symtable2)
8873 free (symtable2);
c0f00686
L		 8874 if (info->reduce_memory_overheads)
8875 {
8876 if (isymbuf1)
8877 free (isymbuf1);
8878 if (isymbuf2)
8879 free (isymbuf2);
8880 }
3d7f7666
L		 8881
8882 return result;
8883}
3b22753a
L		 8884
8885/* It is only used by x86-64 so far. */
8886asection _bfd_elf_large_com_section
8887 = BFD_FAKE_SECTION (_bfd_elf_large_com_section,
f592407e 8888 SEC_IS_COMMON, NULL, "LARGE_COMMON", 0);
ecca9871
L		 8889
8890/* Return TRUE if 2 section types are compatible. */
8891
8892bfd_boolean
8893_bfd_elf_match_sections_by_type (bfd *abfd, const asection *asec,
8894 bfd *bbfd, const asection *bsec)
8895{
8896 if (asec == NULL
8897 || bsec == NULL
8898 || abfd->xvec->flavour != bfd_target_elf_flavour
8899 || bbfd->xvec->flavour != bfd_target_elf_flavour)
8900 return TRUE;
8901
8902 return elf_section_type (asec) == elf_section_type (bsec);
8903}
GDB Binutils - Deliverables
This page took 1.000237 seconds and 4 git commands to generate.