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