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