]> Git Repo - binutils.git/blame - bfd/elf-eh-frame.c
projects / binutils.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gas/ppc/booke.d: Adjust output for corrected condition reg.
[binutils.git] / bfd / elf-eh-frame.c
CommitLineData
65765700 1/* .eh_frame section optimization.
c68836a9 2 Copyright 2001, 2002 Free Software Foundation, Inc.
65765700
JJ		 3 Written by Jakub Jelinek <[email protected]>.
4
5This file is part of BFD, the Binary File Descriptor library.
6
7This program is free software; you can redistribute it and/or modify
8it under the terms of the GNU General Public License as published by
9the Free Software Foundation; either version 2 of the License, or
10(at your option) any later version.
11
12This program is distributed in the hope that it will be useful,
13but WITHOUT ANY WARRANTY; without even the implied warranty of
14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15GNU General Public License for more details.
16
17You should have received a copy of the GNU General Public License
18along with this program; if not, write to the Free Software
19Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20
21#include "bfd.h"
22#include "sysdep.h"
23#include "libbfd.h"
24#include "elf-bfd.h"
25#include "elf/dwarf2.h"
26
27#define EH_FRAME_HDR_SIZE 8
28
29struct cie_header
30{
31 unsigned int length;
32 unsigned int id;
33};
34
35struct cie
36{
37 struct cie_header hdr;
38 unsigned char version;
39 unsigned char augmentation[20];
40 unsigned int code_align;
41 int data_align;
42 unsigned int ra_column;
43 unsigned int augmentation_size;
44 struct elf_link_hash_entry *personality;
45 unsigned char per_encoding;
46 unsigned char lsda_encoding;
47 unsigned char fde_encoding;
48 unsigned char initial_insn_length;
49 unsigned char make_relative;
9e2a4898 50 unsigned char make_lsda_relative;
65765700
JJ		 51 unsigned char initial_instructions[50];
52};
53
54struct eh_cie_fde
55{
56 unsigned int offset;
57 unsigned int size;
58 asection *sec;
59 unsigned int new_offset;
60 unsigned char fde_encoding;
9e2a4898
JJ		 61 unsigned char lsda_encoding;
62 unsigned char lsda_offset;
65765700
JJ		 63 unsigned char cie : 1;
64 unsigned char removed : 1;
65 unsigned char make_relative : 1;
9e2a4898 66 unsigned char make_lsda_relative : 1;
09ae86c2 67 unsigned char per_encoding_relative : 1;
65765700
JJ		 68};
69
70struct eh_frame_sec_info
71{
72 unsigned int count;
73 unsigned int alloced;
74 struct eh_cie_fde entry[1];
75};
76
77struct eh_frame_array_ent
78{
79 bfd_vma initial_loc;
80 bfd_vma fde;
81};
82
83struct eh_frame_hdr_info
84{
85 struct cie last_cie;
86 asection *last_cie_sec;
87 unsigned int last_cie_offset;
88 unsigned int fde_count, array_count;
89 struct eh_frame_array_ent *array;
90 /* TRUE if .eh_frame_hdr should contain the sorted search table.
91 We build it if we successfully read all .eh_frame input sections
92 and recognize them. */
93 boolean table;
68f69152 94 boolean strip;
65765700
JJ		 95};
96
97static bfd_vma read_unsigned_leb128
98 PARAMS ((bfd *, char *, unsigned int *));
99static bfd_signed_vma read_signed_leb128
100 PARAMS ((bfd *, char *, unsigned int *));
101static int get_DW_EH_PE_width
102 PARAMS ((int, int));
9e2a4898
JJ		 103static bfd_vma read_value
104 PARAMS ((bfd *, bfd_byte *, int));
105static void write_value
106 PARAMS ((bfd *, bfd_byte *, bfd_vma, int));
65765700
JJ		 107static int cie_compare
108 PARAMS ((struct cie *, struct cie *));
109static int vma_compare
110 PARAMS ((const PTR a, const PTR b));
111
112/* Helper function for reading uleb128 encoded data. */
113
114static bfd_vma
115read_unsigned_leb128 (abfd, buf, bytes_read_ptr)
116 bfd *abfd ATTRIBUTE_UNUSED;
117 char *buf;
118 unsigned int *bytes_read_ptr;
119{
120 bfd_vma result;
121 unsigned int num_read;
122 int shift;
123 unsigned char byte;
124
125 result = 0;
126 shift = 0;
127 num_read = 0;
128 do
129 {
130 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
131 buf ++;
132 num_read ++;
133 result |= (((bfd_vma) byte & 0x7f) << shift);
134 shift += 7;
135 }
136 while (byte & 0x80);
137 * bytes_read_ptr = num_read;
138 return result;
139}
140
141/* Helper function for reading sleb128 encoded data. */
142
143static bfd_signed_vma
144read_signed_leb128 (abfd, buf, bytes_read_ptr)
145 bfd *abfd ATTRIBUTE_UNUSED;
146 char *buf;
147 unsigned int * bytes_read_ptr;
148{
149 bfd_vma result;
150 int shift;
151 int num_read;
152 unsigned char byte;
153
154 result = 0;
155 shift = 0;
156 num_read = 0;
157 do
158 {
159 byte = bfd_get_8 (abfd, (bfd_byte *) buf);
160 buf ++;
161 num_read ++;
162 result |= (((bfd_vma) byte & 0x7f) << shift);
163 shift += 7;
164 }
165 while (byte & 0x80);
166 if (byte & 0x40)
167 result |= (((bfd_vma) -1) << (shift - 7)) << 7;
168 * bytes_read_ptr = num_read;
169 return result;
170}
171
172#define read_uleb128(VAR, BUF) \
173do \
174 { \
175 (VAR) = read_unsigned_leb128 (abfd, buf, &leb128_tmp); \
176 (BUF) += leb128_tmp; \
177 } \
178while (0)
179
180#define read_sleb128(VAR, BUF) \
181do \
182 { \
183 (VAR) = read_signed_leb128 (abfd, buf, &leb128_tmp); \
184 (BUF) += leb128_tmp; \
185 } \
186while (0)
187
188/* Return 0 if either encoding is variable width, or not yet known to bfd. */
189
190static
191int get_DW_EH_PE_width (encoding, ptr_size)
192 int encoding, ptr_size;
193{
194 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
195 was added to bfd. */
196 if ((encoding & 0x60) == 0x60)
197 return 0;
198
199 switch (encoding & 7)
200 {
201 case DW_EH_PE_udata2: return 2;
202 case DW_EH_PE_udata4: return 4;
203 case DW_EH_PE_udata8: return 8;
204 case DW_EH_PE_absptr: return ptr_size;
205 default:
206 break;
207 }
208
209 return 0;
210}
211
9e2a4898
JJ		 212/* Read a width sized value from memory. */
213
214static bfd_vma
215read_value (abfd, buf, width)
216 bfd *abfd;
217 bfd_byte *buf;
218 int width;
219{
220 bfd_vma value;
221
222 switch (width)
223 {
224 case 2: value = bfd_get_16 (abfd, buf); break;
225 case 4: value = bfd_get_32 (abfd, buf); break;
226 case 8: value = bfd_get_64 (abfd, buf); break;
227 default: BFD_FAIL (); return 0;
228 }
229
230 return value;
231}
232
233/* Store a width sized value to memory. */
234
235static void
236write_value (abfd, buf, value, width)
237 bfd *abfd;
238 bfd_byte *buf;
239 bfd_vma value;
240 int width;
241{
242 switch (width)
243 {
244 case 2: bfd_put_16 (abfd, value, buf); break;
245 case 4: bfd_put_32 (abfd, value, buf); break;
246 case 8: bfd_put_64 (abfd, value, buf); break;
247 default: BFD_FAIL ();
248 }
249}
250
65765700
JJ		 251/* Return zero if C1 and C2 CIEs can be merged. */
252
253static
254int cie_compare (c1, c2)
255 struct cie *c1, *c2;
256{
257 if (c1->hdr.length == c2->hdr.length
258 && c1->version == c2->version
259 && strcmp (c1->augmentation, c2->augmentation) == 0
260 && strcmp (c1->augmentation, "eh") != 0
261 && c1->code_align == c2->code_align
262 && c1->data_align == c2->data_align
263 && c1->ra_column == c2->ra_column
264 && c1->augmentation_size == c2->augmentation_size
265 && c1->personality == c2->personality
266 && c1->per_encoding == c2->per_encoding
267 && c1->lsda_encoding == c2->lsda_encoding
268 && c1->fde_encoding == c2->fde_encoding
269 && (c1->initial_insn_length
270 == c2->initial_insn_length)
271 && memcmp (c1->initial_instructions,
272 c2->initial_instructions,
273 c1->initial_insn_length) == 0)
274 return 0;
275
276 return 1;
277}
278
279/* This function is called for each input file before the .eh_frame
280 section is relocated. It discards duplicate CIEs and FDEs for discarded
281 functions. The function returns true iff any entries have been
282 deleted. */
283
284boolean
285_bfd_elf_discard_section_eh_frame (abfd, info, sec, ehdrsec,
286 reloc_symbol_deleted_p, cookie)
287 bfd *abfd;
288 struct bfd_link_info *info;
289 asection *sec, *ehdrsec;
8c2ab17d 290 boolean (*reloc_symbol_deleted_p) PARAMS ((bfd_vma, PTR));
65765700
JJ		 291 struct elf_reloc_cookie *cookie;
292{
293 bfd_byte *ehbuf = NULL, *buf;
294 bfd_byte *last_cie, *last_fde;
295 struct cie_header hdr;
296 struct cie cie;
297 struct eh_frame_hdr_info *hdr_info;
68f69152 298 struct eh_frame_sec_info *sec_info = NULL;
65765700 299 unsigned int leb128_tmp;
9e2a4898
JJ		 300 unsigned int cie_usage_count, last_cie_ndx, i, offset;
301 unsigned int make_relative, make_lsda_relative;
65765700
JJ		 302 Elf_Internal_Rela *rel;
303 bfd_size_type new_size;
304 unsigned int ptr_size;
305
306 if (sec->_raw_size == 0)
307 {
308 /* This file does not contain .eh_frame information. */
309 return false;
310 }
311
312 if ((sec->output_section != NULL
313 && bfd_is_abs_section (sec->output_section)))
314 {
315 /* At least one of the sections is being discarded from the
316 link, so we should just ignore them. */
317 return false;
318 }
319
68f69152
JJ		 320 BFD_ASSERT (elf_section_data (ehdrsec)->sec_info_type
321 == ELF_INFO_TYPE_EH_FRAME_HDR);
322 hdr_info = (struct eh_frame_hdr_info *)
323 elf_section_data (ehdrsec)->sec_info;
324
65765700
JJ		 325 /* Read the frame unwind information from abfd. */
326
327 ehbuf = (bfd_byte *) bfd_malloc (sec->_raw_size);
68f69152
JJ		 328 if (ehbuf == NULL)
329 goto free_no_table;
330
331 if (! bfd_get_section_contents (abfd, sec, ehbuf, (bfd_vma) 0,
332 sec->_raw_size))
333 goto free_no_table;
65765700
JJ		 334
335 if (sec->_raw_size >= 4
336 && bfd_get_32 (abfd, ehbuf) == 0
337 && cookie->rel == cookie->relend)
338 {
339 /* Empty .eh_frame section. */
340 free (ehbuf);
341 return false;
342 }
343
65765700
JJ		 344 /* If .eh_frame section size doesn't fit into int, we cannot handle
345 it (it would need to use 64-bit .eh_frame format anyway). */
346 if (sec->_raw_size != (unsigned int) sec->_raw_size)
68f69152 347 goto free_no_table;
65765700
JJ		 348
349 ptr_size = (elf_elfheader (abfd)->e_ident[EI_CLASS]
350 == ELFCLASS64) ? 8 : 4;
351 buf = ehbuf;
352 last_cie = NULL;
353 last_cie_ndx = 0;
354 memset (&cie, 0, sizeof (cie));
355 cie_usage_count = 0;
356 new_size = sec->_raw_size;
357 make_relative = hdr_info->last_cie.make_relative;
9e2a4898 358 make_lsda_relative = hdr_info->last_cie.make_lsda_relative;
65765700
JJ		 359 sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
360 + 99 * sizeof (struct eh_cie_fde));
361 if (sec_info == NULL)
362 goto free_no_table;
363 sec_info->alloced = 100;
364
365#define ENSURE_NO_RELOCS(buf) \
366 if (cookie->rel < cookie->relend \
367 && (cookie->rel->r_offset \
368 < (bfd_size_type) ((buf) - ehbuf))) \
369 goto free_no_table
370
371#define SKIP_RELOCS(buf) \
372 while (cookie->rel < cookie->relend \
373 && (cookie->rel->r_offset \
374 < (bfd_size_type) ((buf) - ehbuf))) \
375 cookie->rel++
376
377#define GET_RELOC(buf) \
378 ((cookie->rel < cookie->relend \
379 && (cookie->rel->r_offset \
380 == (bfd_size_type) ((buf) - ehbuf))) \
381 ? cookie->rel : NULL)
382
383 for (;;)
384 {
385 unsigned char *aug;
386
387 if (sec_info->count == sec_info->alloced)
388 {
389 sec_info = bfd_realloc (sec_info,
390 sizeof (struct eh_frame_sec_info)
391 + (sec_info->alloced + 99)
392 * sizeof (struct eh_cie_fde));
393 if (sec_info == NULL)
394 goto free_no_table;
395
396 memset (&sec_info->entry[sec_info->alloced], 0,
397 100 * sizeof (struct eh_cie_fde));
398 sec_info->alloced += 100;
399 }
400
401 last_fde = buf;
402 /* If we are at the end of the section, we still need to decide
403 on whether to output or discard last encountered CIE (if any). */
404 if ((bfd_size_type) (buf - ehbuf) == sec->_raw_size)
405 hdr.id = (unsigned int) -1;
406 else
407 {
408 if ((bfd_size_type) (buf + 4 - ehbuf) > sec->_raw_size)
409 /* No space for CIE/FDE header length. */
410 goto free_no_table;
411
412 hdr.length = bfd_get_32 (abfd, buf);
413 if (hdr.length == 0xffffffff)
414 /* 64-bit .eh_frame is not supported. */
415 goto free_no_table;
416 buf += 4;
e68cc12e 417 if ((bfd_size_type) (buf - ehbuf) + hdr.length > sec->_raw_size)
65765700
JJ		 418 /* CIE/FDE not contained fully in this .eh_frame input section. */
419 goto free_no_table;
420
421 sec_info->entry[sec_info->count].offset = last_fde - ehbuf;
422 sec_info->entry[sec_info->count].size = 4 + hdr.length;
423
424 if (hdr.length == 0)
425 {
426 /* CIE with length 0 must be only the last in the section. */
427 if ((bfd_size_type) (buf - ehbuf) < sec->_raw_size)
428 goto free_no_table;
429 ENSURE_NO_RELOCS (buf);
430 sec_info->count++;
431 /* Now just finish last encountered CIE processing and break
432 the loop. */
433 hdr.id = (unsigned int) -1;
434 }
435 else
436 {
437 hdr.id = bfd_get_32 (abfd, buf);
438 buf += 4;
439 if (hdr.id == (unsigned int) -1)
440 goto free_no_table;
441 }
442 }
443
444 if (hdr.id == 0 || hdr.id == (unsigned int) -1)
445 {
446 unsigned int initial_insn_length;
447
448 /* CIE */
449 if (last_cie != NULL)
450 {
451 /* Now check if this CIE is identical to last CIE, in which case
452 we can remove it, provided we adjust all FDEs.
453 Also, it can be removed if we have removed all FDEs using
454 that. */
455 if (cie_compare (&cie, &hdr_info->last_cie) == 0
456 || cie_usage_count == 0)
457 {
458 new_size -= cie.hdr.length + 4;
459 sec_info->entry[last_cie_ndx].removed = 1;
460 sec_info->entry[last_cie_ndx].sec = hdr_info->last_cie_sec;
461 sec_info->entry[last_cie_ndx].new_offset
462 = hdr_info->last_cie_offset;
463 }
464 else
465 {
466 hdr_info->last_cie = cie;
467 hdr_info->last_cie_sec = sec;
468 hdr_info->last_cie_offset = last_cie - ehbuf;
469 sec_info->entry[last_cie_ndx].make_relative
470 = cie.make_relative;
9e2a4898
JJ		 471 sec_info->entry[last_cie_ndx].make_lsda_relative
472 = cie.make_lsda_relative;
09ae86c2
JJ		 473 sec_info->entry[last_cie_ndx].per_encoding_relative
474 = (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
65765700
JJ		 475 }
476 }
477
478 if (hdr.id == (unsigned int) -1)
479 break;
480
481 last_cie_ndx = sec_info->count;
482 sec_info->entry[sec_info->count].cie = 1;
483
484 cie_usage_count = 0;
485 memset (&cie, 0, sizeof (cie));
486 cie.hdr = hdr;
487 cie.version = *buf++;
488
489 /* Cannot handle unknown versions. */
490 if (cie.version != 1)
491 goto free_no_table;
492 if (strlen (buf) > sizeof (cie.augmentation) - 1)
493 goto free_no_table;
494
495 strcpy (cie.augmentation, buf);
496 buf = strchr (buf, '\0') + 1;
497 ENSURE_NO_RELOCS (buf);
498 if (buf[0] == 'e' && buf[1] == 'h')
499 {
500 /* GCC < 3.0 .eh_frame CIE */
501 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
502 is private to each CIE, so we don't need it for anything.
503 Just skip it. */
504 buf += ptr_size;
505 SKIP_RELOCS (buf);
506 }
507 read_uleb128 (cie.code_align, buf);
508 read_sleb128 (cie.data_align, buf);
7e326afc
NC		 509 /* Note - in DWARF2 the return address column is an unsigned byte.
510 In DWARF3 it is a ULEB128. We are following DWARF3. For most
511 ports this will not matter as the value will be less than 128.
512 For the others (eg FRV, SH, MMIX, IA64) they need a fixed GCC
513 which conforms to the DWARF3 standard. */
514 read_uleb128 (cie.ra_column, buf);
65765700
JJ		 515 ENSURE_NO_RELOCS (buf);
516 cie.lsda_encoding = DW_EH_PE_omit;
517 cie.fde_encoding = DW_EH_PE_omit;
518 cie.per_encoding = DW_EH_PE_omit;
519 aug = cie.augmentation;
520 if (aug[0] != 'e' || aug[1] != 'h')
521 {
522 if (*aug == 'z')
523 {
524 aug++;
525 read_uleb128 (cie.augmentation_size, buf);
526 ENSURE_NO_RELOCS (buf);
527 }
528
529 while (*aug != '\0')
530 switch (*aug++)
531 {
532 case 'L':
533 cie.lsda_encoding = *buf++;
534 ENSURE_NO_RELOCS (buf);
535 if (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size) == 0)
536 goto free_no_table;
537 break;
538 case 'R':
539 cie.fde_encoding = *buf++;
540 ENSURE_NO_RELOCS (buf);
541 if (get_DW_EH_PE_width (cie.fde_encoding, ptr_size) == 0)
542 goto free_no_table;
543 break;
544 case 'P':
545 {
546 int per_width;
547
548 cie.per_encoding = *buf++;
549 per_width = get_DW_EH_PE_width (cie.per_encoding,
550 ptr_size);
551 if (per_width == 0)
552 goto free_no_table;
553 if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)
554 buf = (ehbuf
555 + ((buf - ehbuf + per_width - 1)
556 & ~((bfd_size_type) per_width - 1)));
557 ENSURE_NO_RELOCS (buf);
558 rel = GET_RELOC (buf);
559 /* Ensure we have a reloc here, against
560 a global symbol. */
561 if (rel != NULL)
562 {
563 unsigned long r_symndx;
564
565#ifdef BFD64
566 if (ptr_size == 8)
567 r_symndx = ELF64_R_SYM (cookie->rel->r_info);
568 else
569#endif
570 r_symndx = ELF32_R_SYM (cookie->rel->r_info);
571 if (r_symndx >= cookie->locsymcount)
572 {
573 struct elf_link_hash_entry *h;
574
575 r_symndx -= cookie->extsymoff;
576 h = cookie->sym_hashes[r_symndx];
577
578 while (h->root.type == bfd_link_hash_indirect
579 || h->root.type == bfd_link_hash_warning)
580 h = (struct elf_link_hash_entry *)
581 h->root.u.i.link;
582
583 cie.personality = h;
584 }
585 cookie->rel++;
586 }
587 buf += per_width;
588 }
589 break;
590 default:
591 /* Unrecognized augmentation. Better bail out. */
592 goto free_no_table;
593 }
594 }
595
596 /* For shared libraries, try to get rid of as many RELATIVE relocs
0bb2d96a
JJ		 597 as possible. */
598 if (info->shared
65765700
JJ		 599 && (cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)
600 cie.make_relative = 1;
601
0bb2d96a 602 if (info->shared
9e2a4898
JJ		 603 && (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)
604 cie.make_lsda_relative = 1;
605
65765700
JJ		 606 /* If FDE encoding was not specified, it defaults to
607 DW_EH_absptr. */
608 if (cie.fde_encoding == DW_EH_PE_omit)
609 cie.fde_encoding = DW_EH_PE_absptr;
610
611 initial_insn_length = cie.hdr.length - (buf - last_fde - 4);
612 if (initial_insn_length <= 50)
613 {
614 cie.initial_insn_length = initial_insn_length;
615 memcpy (cie.initial_instructions, buf, initial_insn_length);
616 }
617 buf += initial_insn_length;
618 ENSURE_NO_RELOCS (buf);
619 last_cie = last_fde;
620 }
621 else
622 {
623 /* Ensure this FDE uses the last CIE encountered. */
624 if (last_cie == NULL
625 || hdr.id != (unsigned int) (buf - 4 - last_cie))
626 goto free_no_table;
627
628 ENSURE_NO_RELOCS (buf);
629 rel = GET_RELOC (buf);
630 if (rel == NULL)
631 /* This should not happen. */
632 goto free_no_table;
633 if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
634 {
65765700
JJ		 635 /* This is a FDE against discarded section, it should
636 be deleted. */
637 new_size -= hdr.length + 4;
638 sec_info->entry[sec_info->count].removed = 1;
ad34bc37 639 memset (rel, 0, sizeof (*rel));
65765700
JJ		 640 }
641 else
642 {
0bb2d96a 643 if (info->shared
af40ce3c
JJ		 644 && (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr
645 && cie.make_relative == 0)
646 || (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))
0bb2d96a
JJ		 647 {
648 /* If shared library uses absolute pointers
649 which we cannot turn into PC relative,
650 don't create the binary search table,
651 since it is affected by runtime relocations. */
652 hdr_info->table = false;
653 }
65765700
JJ		 654 cie_usage_count++;
655 hdr_info->fde_count++;
656 }
657 cookie->rel = rel;
9e2a4898
JJ		 658 if (cie.lsda_encoding != DW_EH_PE_omit)
659 {
660 unsigned int dummy;
661
662 aug = buf;
663 buf += 2 * get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
664 if (cie.augmentation[0] == 'z')
665 read_uleb128 (dummy, buf);
666 /* If some new augmentation data is added before LSDA
667 in FDE augmentation area, this need to be adjusted. */
668 sec_info->entry[sec_info->count].lsda_offset = (buf - aug);
669 }
65765700
JJ		 670 buf = last_fde + 4 + hdr.length;
671 SKIP_RELOCS (buf);
672 }
673
674 sec_info->entry[sec_info->count].fde_encoding = cie.fde_encoding;
9e2a4898 675 sec_info->entry[sec_info->count].lsda_encoding = cie.lsda_encoding;
65765700
JJ		 676 sec_info->count++;
677 }
678
679 elf_section_data (sec)->sec_info = sec_info;
680 elf_section_data (sec)->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
681
682 /* Ok, now we can assign new offsets. */
683 offset = 0;
684 last_cie_ndx = 0;
685 for (i = 0; i < sec_info->count; i++)
686 {
687 if (! sec_info->entry[i].removed)
688 {
689 sec_info->entry[i].new_offset = offset;
690 offset += sec_info->entry[i].size;
691 if (sec_info->entry[i].cie)
692 {
693 last_cie_ndx = i;
694 make_relative = sec_info->entry[i].make_relative;
9e2a4898 695 make_lsda_relative = sec_info->entry[i].make_lsda_relative;
65765700
JJ		 696 }
697 else
9e2a4898
JJ		 698 {
699 sec_info->entry[i].make_relative = make_relative;
700 sec_info->entry[i].make_lsda_relative = make_lsda_relative;
09ae86c2 701 sec_info->entry[i].per_encoding_relative = 0;
9e2a4898 702 }
65765700
JJ		 703 }
704 else if (sec_info->entry[i].cie && sec_info->entry[i].sec == sec)
705 {
706 /* Need to adjust new_offset too. */
707 BFD_ASSERT (sec_info->entry[last_cie_ndx].offset
708 == sec_info->entry[i].new_offset);
709 sec_info->entry[i].new_offset
710 = sec_info->entry[last_cie_ndx].new_offset;
711 }
712 }
713 if (hdr_info->last_cie_sec == sec)
714 {
715 BFD_ASSERT (sec_info->entry[last_cie_ndx].offset
716 == hdr_info->last_cie_offset);
717 hdr_info->last_cie_offset = sec_info->entry[last_cie_ndx].new_offset;
718 }
719
a5eb27e6
JJ		 720 /* FIXME: Currently it is not possible to shrink sections to zero size at
721 this point, so build a fake minimal CIE. */
722 if (new_size == 0)
723 new_size = 16;
724
65765700 725 /* Shrink the sec as needed. */
65765700
JJ		 726 sec->_cooked_size = new_size;
727 if (sec->_cooked_size == 0)
728 sec->flags |= SEC_EXCLUDE;
729
68f69152 730 free (ehbuf);
65765700
JJ		 731 return new_size != sec->_raw_size;
732
733free_no_table:
68f69152
JJ		 734 if (ehbuf)
735 free (ehbuf);
65765700
JJ		 736 if (sec_info)
737 free (sec_info);
738 hdr_info->table = false;
739 hdr_info->last_cie.hdr.length = 0;
740 return false;
741}
742
743/* This function is called for .eh_frame_hdr section after
744 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
745 input sections. It finalizes the size of .eh_frame_hdr section. */
746
747boolean
748_bfd_elf_discard_section_eh_frame_hdr (abfd, info, sec)
749 bfd *abfd;
750 struct bfd_link_info *info;
751 asection *sec;
752{
753 struct eh_frame_hdr_info *hdr_info;
754 unsigned int ptr_size;
755
756 ptr_size = (elf_elfheader (abfd)->e_ident[EI_CLASS]
757 == ELFCLASS64) ? 8 : 4;
758
759 if ((elf_section_data (sec)->sec_info_type
760 != ELF_INFO_TYPE_EH_FRAME_HDR)
761 || ! info->eh_frame_hdr)
762 {
763 _bfd_strip_section_from_output (info, sec);
764 return false;
765 }
766
767 hdr_info = (struct eh_frame_hdr_info *)
768 elf_section_data (sec)->sec_info;
68f69152
JJ		 769 if (hdr_info->strip)
770 return false;
65765700
JJ		 771 sec->_cooked_size = EH_FRAME_HDR_SIZE;
772 if (hdr_info->table)
773 sec->_cooked_size += 4 + hdr_info->fde_count * 8;
774
775 /* Request program headers to be recalculated. */
776 elf_tdata (abfd)->program_header_size = 0;
777 elf_tdata (abfd)->eh_frame_hdr = true;
778 return true;
779}
780
68f69152
JJ		 781/* This function is called from size_dynamic_sections.
782 It needs to decide whether .eh_frame_hdr should be output or not,
783 because later on it is too late for calling _bfd_strip_section_from_output,
784 since dynamic symbol table has been sized. */
785
786boolean
787_bfd_elf_maybe_strip_eh_frame_hdr (info)
788 struct bfd_link_info *info;
789{
790 asection *sec, *o;
791 bfd *abfd;
792 struct eh_frame_hdr_info *hdr_info;
793
794 sec = bfd_get_section_by_name (elf_hash_table (info)->dynobj, ".eh_frame_hdr");
2d653fc7 795 if (sec == NULL || bfd_is_abs_section (sec->output_section))
68f69152
JJ		 796 return true;
797
798 hdr_info
799 = bfd_zmalloc (sizeof (struct eh_frame_hdr_info));
800 if (hdr_info == NULL)
801 return false;
802
803 elf_section_data (sec)->sec_info = hdr_info;
804 elf_section_data (sec)->sec_info_type = ELF_INFO_TYPE_EH_FRAME_HDR;
805
806 abfd = NULL;
807 if (info->eh_frame_hdr)
808 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
809 {
810 /* Count only sections which have at least a single CIE or FDE.
811 There cannot be any CIE or FDE <= 8 bytes. */
812 o = bfd_get_section_by_name (abfd, ".eh_frame");
2d653fc7 813 if (o && o->_raw_size > 8 && !bfd_is_abs_section (o->output_section))
68f69152
JJ		 814 break;
815 }
816
817 if (abfd == NULL)
818 {
819 _bfd_strip_section_from_output (info, sec);
820 hdr_info->strip = true;
821 }
822 else
823 hdr_info->table = true;
824 return true;
825}
826
65765700
JJ		 827/* Adjust an address in the .eh_frame section. Given OFFSET within
828 SEC, this returns the new offset in the adjusted .eh_frame section,
829 or -1 if the address refers to a CIE/FDE which has been removed
830 or to offset with dynamic relocation which is no longer needed. */
831
832bfd_vma
833_bfd_elf_eh_frame_section_offset (output_bfd, sec, offset)
834 bfd *output_bfd ATTRIBUTE_UNUSED;
835 asection *sec;
836 bfd_vma offset;
837{
838 struct eh_frame_sec_info *sec_info;
839 unsigned int lo, hi, mid;
840
841 if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
842 return offset;
843 sec_info = (struct eh_frame_sec_info *)
844 elf_section_data (sec)->sec_info;
845
846 if (offset >= sec->_raw_size)
847 return offset - (sec->_cooked_size - sec->_raw_size);
848
849 lo = 0;
850 hi = sec_info->count;
851 mid = 0;
852 while (lo < hi)
853 {
854 mid = (lo + hi) / 2;
855 if (offset < sec_info->entry[mid].offset)
856 hi = mid;
857 else if (offset
858 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
859 lo = mid + 1;
860 else
861 break;
862 }
863
864 BFD_ASSERT (lo < hi);
865
866 /* FDE or CIE was removed. */
867 if (sec_info->entry[mid].removed)
868 return (bfd_vma) -1;
869
870 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
871 relocation against FDE's initial_location field. */
872 if (sec_info->entry[mid].make_relative
873 && ! sec_info->entry[mid].cie
874 && offset == sec_info->entry[mid].offset + 8)
0bb2d96a 875 return (bfd_vma) -2;
65765700 876
9e2a4898
JJ		 877 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
878 for run-time relocation against LSDA field. */
879 if (sec_info->entry[mid].make_lsda_relative
880 && ! sec_info->entry[mid].cie
881 && (offset
882 == (sec_info->entry[mid].offset + 8
883 + sec_info->entry[mid].lsda_offset)))
0bb2d96a 884 return (bfd_vma) -2;
9e2a4898 885
c68836a9
AM		 886 return (offset + sec_info->entry[mid].new_offset
887 - sec_info->entry[mid].offset);
65765700
JJ		 888}
889
890/* Write out .eh_frame section. This is called with the relocated
891 contents. */
892
893boolean
894_bfd_elf_write_section_eh_frame (abfd, sec, ehdrsec, contents)
895 bfd *abfd;
896 asection *sec, *ehdrsec;
897 bfd_byte *contents;
898{
899 struct eh_frame_sec_info *sec_info;
900 struct eh_frame_hdr_info *hdr_info;
901 unsigned int i;
902 bfd_byte *p, *buf;
903 unsigned int leb128_tmp;
904 unsigned int cie_offset = 0;
905 unsigned int ptr_size;
906
907 ptr_size = (elf_elfheader (sec->owner)->e_ident[EI_CLASS]
908 == ELFCLASS64) ? 8 : 4;
909
910 if (elf_section_data (sec)->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
911 return bfd_set_section_contents (abfd, sec->output_section,
912 contents,
913 (file_ptr) sec->output_offset,
914 sec->_raw_size);
915 sec_info = (struct eh_frame_sec_info *)
916 elf_section_data (sec)->sec_info;
917 hdr_info = NULL;
918 if (ehdrsec
919 && (elf_section_data (ehdrsec)->sec_info_type
920 == ELF_INFO_TYPE_EH_FRAME_HDR))
921 {
922 hdr_info = (struct eh_frame_hdr_info *)
923 elf_section_data (ehdrsec)->sec_info;
924 if (hdr_info->table && hdr_info->array == NULL)
925 hdr_info->array
926 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
927 if (hdr_info->array == NULL)
928 hdr_info = NULL;
929 }
930
931 p = contents;
932 for (i = 0; i < sec_info->count; ++i)
933 {
934 if (sec_info->entry[i].removed)
935 {
936 if (sec_info->entry[i].cie)
937 {
a3aa38ee
JJ		 938 /* If CIE is removed due to no remaining FDEs referencing it
939 and there were no CIEs kept before it, sec_info->entry[i].sec
940 will be zero. */
941 if (sec_info->entry[i].sec == NULL)
942 cie_offset = 0;
943 else
944 {
945 cie_offset = sec_info->entry[i].new_offset;
946 cie_offset += (sec_info->entry[i].sec->output_section->vma
947 + sec_info->entry[i].sec->output_offset
948 - sec->output_section->vma
949 - sec->output_offset);
950 }
65765700
JJ		 951 }
952 continue;
953 }
a3aa38ee 954
65765700
JJ		 955 if (sec_info->entry[i].cie)
956 {
957 /* CIE */
958 cie_offset = sec_info->entry[i].new_offset;
9e2a4898 959 if (sec_info->entry[i].make_relative
09ae86c2
JJ		 960 || sec_info->entry[i].make_lsda_relative
961 || sec_info->entry[i].per_encoding_relative)
65765700
JJ		 962 {
963 unsigned char *aug;
9e2a4898 964 unsigned int action;
65765700
JJ		 965 unsigned int dummy, per_width, per_encoding;
966
9e2a4898 967 /* Need to find 'R' or 'L' augmentation's argument and modify
65765700 968 DW_EH_PE_* value. */
9e2a4898 969 action = (sec_info->entry[i].make_relative ? 1 : 0)
09ae86c2
JJ		 970 | (sec_info->entry[i].make_lsda_relative ? 2 : 0)
971 | (sec_info->entry[i].per_encoding_relative ? 4 : 0);
65765700
JJ		 972 buf = contents + sec_info->entry[i].offset;
973 /* Skip length, id and version. */
974 buf += 9;
975 aug = buf;
976 buf = strchr (buf, '\0') + 1;
977 read_uleb128 (dummy, buf);
978 read_sleb128 (dummy, buf);
979 read_uleb128 (dummy, buf);
980 if (*aug == 'z')
981 {
982 read_uleb128 (dummy, buf);
983 aug++;
984 }
985
9e2a4898 986 while (action)
65765700
JJ		 987 switch (*aug++)
988 {
989 case 'L':
9e2a4898
JJ		 990 if (action & 2)
991 {
992 BFD_ASSERT (*buf == sec_info->entry[i].lsda_encoding);
993 *buf |= DW_EH_PE_pcrel;
994 action &= ~2;
995 }
65765700
JJ		 996 buf++;
997 break;
998 case 'P':
999 per_encoding = *buf++;
1000 per_width = get_DW_EH_PE_width (per_encoding,
1001 ptr_size);
1002 BFD_ASSERT (per_width != 0);
09ae86c2
JJ		 1003 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1004 == sec_info->entry[i].per_encoding_relative);
65765700
JJ		 1005 if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1006 buf = (contents
1007 + ((buf - contents + per_width - 1)
1008 & ~((bfd_size_type) per_width - 1)));
09ae86c2
JJ		 1009 if (action & 4)
1010 {
1011 bfd_vma value;
1012
1013 value = read_value (abfd, buf, per_width);
1014 value += (sec_info->entry[i].offset
1015 - sec_info->entry[i].new_offset);
1016 write_value (abfd, buf, value, per_width);
1017 action &= ~4;
1018 }
65765700
JJ		 1019 buf += per_width;
1020 break;
9e2a4898
JJ		 1021 case 'R':
1022 if (action & 1)
1023 {
1024 BFD_ASSERT (*buf == sec_info->entry[i].fde_encoding);
1025 *buf |= DW_EH_PE_pcrel;
1026 action &= ~1;
1027 }
1028 buf++;
1029 break;
65765700
JJ		 1030 default:
1031 BFD_FAIL ();
1032 }
65765700
JJ		 1033 }
1034 }
af40ce3c 1035 else if (sec_info->entry[i].size > 4)
65765700
JJ		 1036 {
1037 /* FDE */
1038 bfd_vma value = 0, address;
9e2a4898 1039 unsigned int width;
65765700
JJ		 1040
1041 buf = contents + sec_info->entry[i].offset;
1042 /* Skip length. */
1043 buf += 4;
1044 bfd_put_32 (abfd,
1045 sec_info->entry[i].new_offset + 4 - cie_offset, buf);
1046 buf += 4;
9e2a4898
JJ		 1047 width = get_DW_EH_PE_width (sec_info->entry[i].fde_encoding,
1048 ptr_size);
1049 address = value = read_value (abfd, buf, width);
1050 if (value)
65765700 1051 {
9e2a4898
JJ		 1052 switch (sec_info->entry[i].fde_encoding & 0xf0)
1053 {
1054 case DW_EH_PE_indirect:
1055 case DW_EH_PE_textrel:
1056 BFD_ASSERT (hdr_info == NULL);
1057 break;
1058 case DW_EH_PE_datarel:
1059 {
1060 asection *got = bfd_get_section_by_name (abfd, ".got");
1061
1062 BFD_ASSERT (got != NULL);
1063 address += got->vma;
1064 }
1065 break;
1066 case DW_EH_PE_pcrel:
1067 value += (sec_info->entry[i].offset
1068 - sec_info->entry[i].new_offset);
1069 address += (sec->output_section->vma + sec->output_offset
1070 + sec_info->entry[i].offset + 8);
1071 break;
1072 }
1073 if (sec_info->entry[i].make_relative)
1074 value -= (sec->output_section->vma + sec->output_offset
65765700 1075 + sec_info->entry[i].new_offset + 8);
9e2a4898 1076 write_value (abfd, buf, value, width);
65765700
JJ		 1077 }
1078
1079 if (hdr_info)
1080 {
1081 hdr_info->array[hdr_info->array_count].initial_loc = address;
1082 hdr_info->array[hdr_info->array_count++].fde
1083 = (sec->output_section->vma + sec->output_offset
1084 + sec_info->entry[i].new_offset);
1085 }
9e2a4898
JJ		 1086
1087 if ((sec_info->entry[i].lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1088 || sec_info->entry[i].make_lsda_relative)
1089 {
1090 buf += sec_info->entry[i].lsda_offset;
1091 width = get_DW_EH_PE_width (sec_info->entry[i].lsda_encoding,
1092 ptr_size);
1093 value = read_value (abfd, buf, width);
1094 if (value)
1095 {
1096 if ((sec_info->entry[i].lsda_encoding & 0xf0)
1097 == DW_EH_PE_pcrel)
1098 value += (sec_info->entry[i].offset
1099 - sec_info->entry[i].new_offset);
1100 else if (sec_info->entry[i].make_lsda_relative)
1101 value -= (sec->output_section->vma + sec->output_offset
1102 + sec_info->entry[i].new_offset + 8
1103 + sec_info->entry[i].lsda_offset);
1104 write_value (abfd, buf, value, width);
1105 }
1106 }
65765700 1107 }
af40ce3c
JJ		 1108 else
1109 /* Terminating FDE must be at the end of .eh_frame section only. */
1110 BFD_ASSERT (i == sec_info->count - 1);
65765700
JJ		 1111
1112 BFD_ASSERT (p == contents + sec_info->entry[i].new_offset);
1113 memmove (p, contents + sec_info->entry[i].offset,
1114 sec_info->entry[i].size);
1115 p += sec_info->entry[i].size;
1116 }
1117
a5eb27e6
JJ		 1118 /* FIXME: Once _bfd_elf_discard_section_eh_frame will be able to
1119 shrink sections to zero size, this won't be needed any more. */
1120 if (p == contents && sec->_cooked_size == 16)
1121 {
1122 bfd_put_32 (abfd, 12, p); /* Fake CIE length */
1123 bfd_put_32 (abfd, 0, p + 4); /* Fake CIE id */
1124 p[8] = 1; /* Fake CIE version */
1125 memset (p + 9, 0, 7); /* Fake CIE augmentation, 3xleb128
1126 and 3xDW_CFA_nop as pad */
1127 p += 16;
1128 }
1129
65765700
JJ		 1130 BFD_ASSERT ((bfd_size_type) (p - contents) == sec->_cooked_size);
1131
1132 return bfd_set_section_contents (abfd, sec->output_section,
1133 contents, (file_ptr) sec->output_offset,
1134 sec->_cooked_size);
1135}
1136
1137/* Helper function used to sort .eh_frame_hdr search table by increasing
1138 VMA of FDE initial location. */
1139
1140static int
1141vma_compare (a, b)
1142 const PTR a;
1143 const PTR b;
1144{
1145 struct eh_frame_array_ent *p = (struct eh_frame_array_ent *) a;
1146 struct eh_frame_array_ent *q = (struct eh_frame_array_ent *) b;
1147 if (p->initial_loc > q->initial_loc)
1148 return 1;
1149 if (p->initial_loc < q->initial_loc)
1150 return -1;
1151 return 0;
1152}
1153
1154/* Write out .eh_frame_hdr section. This must be called after
1155 _bfd_elf_write_section_eh_frame has been called on all input
1156 .eh_frame sections.
1157 .eh_frame_hdr format:
1158 ubyte version (currently 1)
1159 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1160 .eh_frame section)
1161 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1162 number (or DW_EH_PE_omit if there is no
1163 binary search table computed))
1164 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1165 or DW_EH_PE_omit if not present.
1166 DW_EH_PE_datarel is using address of
1167 .eh_frame_hdr section start as base)
1168 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1169 optionally followed by:
1170 [encoded] fde_count (total number of FDEs in .eh_frame section)
1171 fde_count x [encoded] initial_loc, fde
1172 (array of encoded pairs containing
1173 FDE initial_location field and FDE address,
1174 sorted by increasing initial_loc) */
1175
1176boolean
1177_bfd_elf_write_section_eh_frame_hdr (abfd, sec)
1178 bfd *abfd;
1179 asection *sec;
1180{
1181 struct eh_frame_hdr_info *hdr_info;
1182 unsigned int ptr_size;
1183 bfd_byte *contents;
1184 asection *eh_frame_sec;
1185 bfd_size_type size;
1186
1187 ptr_size = (elf_elfheader (sec->owner)->e_ident[EI_CLASS]
1188 == ELFCLASS64) ? 8 : 4;
1189
1190 BFD_ASSERT (elf_section_data (sec)->sec_info_type
1191 == ELF_INFO_TYPE_EH_FRAME_HDR);
1192 hdr_info = (struct eh_frame_hdr_info *)
1193 elf_section_data (sec)->sec_info;
57a72197
JJ		 1194 if (hdr_info->strip)
1195 return true;
1196
65765700
JJ		 1197 size = EH_FRAME_HDR_SIZE;
1198 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1199 size += 4 + hdr_info->fde_count * 8;
1200 contents = bfd_malloc (size);
1201 if (contents == NULL)
1202 return false;
1203
1204 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1205 if (eh_frame_sec == NULL)
1206 return false;
1207
1208 memset (contents, 0, EH_FRAME_HDR_SIZE);
1209 contents[0] = 1; /* Version */
1210 contents[1] = DW_EH_PE_pcrel | DW_EH_PE_sdata4; /* .eh_frame offset */
1211 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1212 {
1213 contents[2] = DW_EH_PE_udata4; /* FDE count encoding */
1214 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* search table enc */
1215 }
1216 else
1217 {
1218 contents[2] = DW_EH_PE_omit;
1219 contents[3] = DW_EH_PE_omit;
1220 }
1221 bfd_put_32 (abfd, eh_frame_sec->vma - sec->output_section->vma - 4,
1222 contents + 4);
1223 if (contents[2] != DW_EH_PE_omit)
1224 {
1225 unsigned int i;
1226
1227 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1228 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1229 vma_compare);
1230 for (i = 0; i < hdr_info->fde_count; i++)
1231 {
1232 bfd_put_32 (abfd,
1233 hdr_info->array[i].initial_loc
1234 - sec->output_section->vma,
1235 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1236 bfd_put_32 (abfd,
1237 hdr_info->array[i].fde - sec->output_section->vma,
1238 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1239 }
1240 }
1241
1242 return bfd_set_section_contents (abfd, sec->output_section,
1243 contents, (file_ptr) sec->output_offset,
1244 sec->_cooked_size);
1245}
Empty description
This page took 0.320208 seconds and 4 git commands to generate.