1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4 Written by Jakub Jelinek <jakub@redhat.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
27 #include "elf/dwarf2.h"
29 #define EH_FRAME_HDR_SIZE 8
35 unsigned char version
;
36 unsigned char local_personality
;
37 char augmentation
[20];
39 bfd_signed_vma data_align
;
41 bfd_vma augmentation_size
;
43 struct elf_link_hash_entry
*h
;
45 unsigned int reloc_index
;
48 struct eh_cie_fde
*cie_inf
;
49 unsigned char per_encoding
;
50 unsigned char lsda_encoding
;
51 unsigned char fde_encoding
;
52 unsigned char initial_insn_length
;
53 unsigned char can_make_lsda_relative
;
54 unsigned char initial_instructions
[50];
59 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
60 move onto the next byte. Return true on success. */
62 static inline bfd_boolean
63 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
67 *result
= *((*iter
)++);
71 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
72 Return true it was possible to move LENGTH bytes. */
74 static inline bfd_boolean
75 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
77 if ((bfd_size_type
) (end
- *iter
) < length
)
86 /* Move *ITER over an leb128, stopping at END. Return true if the end
87 of the leb128 was found. */
90 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
94 if (!read_byte (iter
, end
, &byte
))
100 /* Like skip_leb128, but treat the leb128 as an unsigned value and
101 store it in *VALUE. */
104 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
109 if (!skip_leb128 (iter
, end
))
115 *value
= (*value
<< 7) | (*--p
& 0x7f);
120 /* Like read_uleb128, but for signed values. */
123 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
128 if (!skip_leb128 (iter
, end
))
132 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
134 *value
= (*value
<< 7) | (*--p
& 0x7f);
139 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
142 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
144 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
146 if ((encoding
& 0x60) == 0x60)
149 switch (encoding
& 7)
151 case DW_EH_PE_udata2
: return 2;
152 case DW_EH_PE_udata4
: return 4;
153 case DW_EH_PE_udata8
: return 8;
154 case DW_EH_PE_absptr
: return ptr_size
;
162 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164 /* Read a width sized value from memory. */
167 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
175 value
= bfd_get_signed_16 (abfd
, buf
);
177 value
= bfd_get_16 (abfd
, buf
);
181 value
= bfd_get_signed_32 (abfd
, buf
);
183 value
= bfd_get_32 (abfd
, buf
);
187 value
= bfd_get_signed_64 (abfd
, buf
);
189 value
= bfd_get_64 (abfd
, buf
);
199 /* Store a width sized value to memory. */
202 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
206 case 2: bfd_put_16 (abfd
, value
, buf
); break;
207 case 4: bfd_put_32 (abfd
, value
, buf
); break;
208 case 8: bfd_put_64 (abfd
, value
, buf
); break;
209 default: BFD_FAIL ();
213 /* Return one if C1 and C2 CIEs can be merged. */
216 cie_eq (const void *e1
, const void *e2
)
218 const struct cie
*c1
= e1
;
219 const struct cie
*c2
= e2
;
221 if (c1
->hash
== c2
->hash
222 && c1
->length
== c2
->length
223 && c1
->version
== c2
->version
224 && c1
->local_personality
== c2
->local_personality
225 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
226 && strcmp (c1
->augmentation
, "eh") != 0
227 && c1
->code_align
== c2
->code_align
228 && c1
->data_align
== c2
->data_align
229 && c1
->ra_column
== c2
->ra_column
230 && c1
->augmentation_size
== c2
->augmentation_size
231 && memcmp (&c1
->personality
, &c2
->personality
,
232 sizeof (c1
->personality
)) == 0
233 && c1
->output_sec
== c2
->output_sec
234 && c1
->per_encoding
== c2
->per_encoding
235 && c1
->lsda_encoding
== c2
->lsda_encoding
236 && c1
->fde_encoding
== c2
->fde_encoding
237 && c1
->initial_insn_length
== c2
->initial_insn_length
238 && memcmp (c1
->initial_instructions
,
239 c2
->initial_instructions
,
240 c1
->initial_insn_length
) == 0)
247 cie_hash (const void *e
)
249 const struct cie
*c
= e
;
254 cie_compute_hash (struct cie
*c
)
257 h
= iterative_hash_object (c
->length
, h
);
258 h
= iterative_hash_object (c
->version
, h
);
259 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
260 h
= iterative_hash_object (c
->code_align
, h
);
261 h
= iterative_hash_object (c
->data_align
, h
);
262 h
= iterative_hash_object (c
->ra_column
, h
);
263 h
= iterative_hash_object (c
->augmentation_size
, h
);
264 h
= iterative_hash_object (c
->personality
, h
);
265 h
= iterative_hash_object (c
->output_sec
, h
);
266 h
= iterative_hash_object (c
->per_encoding
, h
);
267 h
= iterative_hash_object (c
->lsda_encoding
, h
);
268 h
= iterative_hash_object (c
->fde_encoding
, h
);
269 h
= iterative_hash_object (c
->initial_insn_length
, h
);
270 h
= iterative_hash (c
->initial_instructions
, c
->initial_insn_length
, h
);
275 /* Return the number of extra bytes that we'll be inserting into
276 ENTRY's augmentation string. */
278 static INLINE
unsigned int
279 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
281 unsigned int size
= 0;
284 if (entry
->add_augmentation_size
)
286 if (entry
->u
.cie
.add_fde_encoding
)
292 /* Likewise ENTRY's augmentation data. */
294 static INLINE
unsigned int
295 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
297 unsigned int size
= 0;
298 if (entry
->add_augmentation_size
)
300 if (entry
->cie
&& entry
->u
.cie
.add_fde_encoding
)
305 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
306 required alignment of ENTRY in bytes. */
309 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
313 if (entry
->size
== 4)
316 + extra_augmentation_string_bytes (entry
)
317 + extra_augmentation_data_bytes (entry
)
318 + alignment
- 1) & -alignment
;
321 /* Assume that the bytes between *ITER and END are CFA instructions.
322 Try to move *ITER past the first instruction and return true on
323 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
326 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
331 if (!read_byte (iter
, end
, &op
))
334 switch (op
& 0xc0 ? op
& 0xc0 : op
)
337 case DW_CFA_advance_loc
:
339 case DW_CFA_remember_state
:
340 case DW_CFA_restore_state
:
341 case DW_CFA_GNU_window_save
:
346 case DW_CFA_restore_extended
:
347 case DW_CFA_undefined
:
348 case DW_CFA_same_value
:
349 case DW_CFA_def_cfa_register
:
350 case DW_CFA_def_cfa_offset
:
351 case DW_CFA_def_cfa_offset_sf
:
352 case DW_CFA_GNU_args_size
:
353 /* One leb128 argument. */
354 return skip_leb128 (iter
, end
);
356 case DW_CFA_val_offset
:
357 case DW_CFA_val_offset_sf
:
358 case DW_CFA_offset_extended
:
359 case DW_CFA_register
:
361 case DW_CFA_offset_extended_sf
:
362 case DW_CFA_GNU_negative_offset_extended
:
363 case DW_CFA_def_cfa_sf
:
364 /* Two leb128 arguments. */
365 return (skip_leb128 (iter
, end
)
366 && skip_leb128 (iter
, end
));
368 case DW_CFA_def_cfa_expression
:
369 /* A variable-length argument. */
370 return (read_uleb128 (iter
, end
, &length
)
371 && skip_bytes (iter
, end
, length
));
373 case DW_CFA_expression
:
374 case DW_CFA_val_expression
:
375 /* A leb128 followed by a variable-length argument. */
376 return (skip_leb128 (iter
, end
)
377 && read_uleb128 (iter
, end
, &length
)
378 && skip_bytes (iter
, end
, length
));
381 return skip_bytes (iter
, end
, encoded_ptr_width
);
383 case DW_CFA_advance_loc1
:
384 return skip_bytes (iter
, end
, 1);
386 case DW_CFA_advance_loc2
:
387 return skip_bytes (iter
, end
, 2);
389 case DW_CFA_advance_loc4
:
390 return skip_bytes (iter
, end
, 4);
392 case DW_CFA_MIPS_advance_loc8
:
393 return skip_bytes (iter
, end
, 8);
400 /* Try to interpret the bytes between BUF and END as CFA instructions.
401 If every byte makes sense, return a pointer to the first DW_CFA_nop
402 padding byte, or END if there is no padding. Return null otherwise.
403 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
406 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
407 unsigned int *set_loc_count
)
413 if (*buf
== DW_CFA_nop
)
417 if (*buf
== DW_CFA_set_loc
)
419 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
426 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
427 .eh_frame section. */
430 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
432 struct eh_frame_hdr_info
*hdr_info
;
434 hdr_info
= &elf_hash_table (info
)->eh_info
;
435 hdr_info
->merge_cies
= !info
->relocatable
;
438 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
439 information in the section's sec_info field on success. COOKIE
440 describes the relocations in SEC. */
443 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
444 asection
*sec
, struct elf_reloc_cookie
*cookie
)
446 #define REQUIRE(COND) \
449 goto free_no_table; \
452 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
454 struct eh_cie_fde
*this_inf
;
455 unsigned int hdr_length
, hdr_id
;
456 unsigned int cie_count
;
457 struct cie
*cie
, *local_cies
= NULL
;
458 struct elf_link_hash_table
*htab
;
459 struct eh_frame_hdr_info
*hdr_info
;
460 struct eh_frame_sec_info
*sec_info
= NULL
;
461 unsigned int ptr_size
;
462 unsigned int num_cies
;
463 unsigned int num_entries
;
464 elf_gc_mark_hook_fn gc_mark_hook
;
466 htab
= elf_hash_table (info
);
467 hdr_info
= &htab
->eh_info
;
468 if (hdr_info
->parsed_eh_frames
)
473 /* This file does not contain .eh_frame information. */
477 if (bfd_is_abs_section (sec
->output_section
))
479 /* At least one of the sections is being discarded from the
480 link, so we should just ignore them. */
484 /* Read the frame unwind information from abfd. */
486 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
489 && bfd_get_32 (abfd
, ehbuf
) == 0
490 && cookie
->rel
== cookie
->relend
)
492 /* Empty .eh_frame section. */
497 /* If .eh_frame section size doesn't fit into int, we cannot handle
498 it (it would need to use 64-bit .eh_frame format anyway). */
499 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
501 ptr_size
= (get_elf_backend_data (abfd
)
502 ->elf_backend_eh_frame_address_size (abfd
, sec
));
503 REQUIRE (ptr_size
!= 0);
505 /* Go through the section contents and work out how many FDEs and
508 end
= ehbuf
+ sec
->size
;
515 /* Read the length of the entry. */
516 REQUIRE (skip_bytes (&buf
, end
, 4));
517 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
519 /* 64-bit .eh_frame is not supported. */
520 REQUIRE (hdr_length
!= 0xffffffff);
524 REQUIRE (skip_bytes (&buf
, end
, 4));
525 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
529 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
532 sec_info
= bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
533 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
536 /* We need to have a "struct cie" for each CIE in this section. */
537 local_cies
= bfd_zmalloc (num_cies
* sizeof (*local_cies
));
538 REQUIRE (local_cies
);
540 #define ENSURE_NO_RELOCS(buf) \
541 REQUIRE (!(cookie->rel < cookie->relend \
542 && (cookie->rel->r_offset \
543 < (bfd_size_type) ((buf) - ehbuf)) \
544 && cookie->rel->r_info != 0))
546 #define SKIP_RELOCS(buf) \
547 while (cookie->rel < cookie->relend \
548 && (cookie->rel->r_offset \
549 < (bfd_size_type) ((buf) - ehbuf))) \
552 #define REQUIRE_CLEARED_RELOCS(buf) \
553 while (cookie->rel < cookie->relend \
554 && (cookie->rel->r_offset \
555 < (bfd_size_type) ((buf) - ehbuf))) \
557 REQUIRE (cookie->rel->r_info == 0); \
558 REQUIRE (cookie->rel->r_addend == 0); \
562 #define GET_RELOC(buf) \
563 ((cookie->rel < cookie->relend \
564 && (cookie->rel->r_offset \
565 == (bfd_size_type) ((buf) - ehbuf))) \
566 ? cookie->rel : NULL)
570 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
571 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
574 bfd_byte
*start
, *insns
, *insns_end
;
575 bfd_size_type length
;
576 unsigned int set_loc_count
;
578 this_inf
= sec_info
->entry
+ sec_info
->count
;
581 /* Read the length of the entry. */
582 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
583 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
585 /* The CIE/FDE must be fully contained in this input section. */
586 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
587 end
= buf
+ hdr_length
;
589 this_inf
->offset
= last_fde
- ehbuf
;
590 this_inf
->size
= 4 + hdr_length
;
591 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
595 /* A zero-length CIE should only be found at the end of
597 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
598 ENSURE_NO_RELOCS (buf
);
603 REQUIRE (skip_bytes (&buf
, end
, 4));
604 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
608 unsigned int initial_insn_length
;
613 /* Point CIE to one of the section-local cie structures. */
614 cie
= local_cies
+ cie_count
++;
616 cie
->cie_inf
= this_inf
;
617 cie
->length
= hdr_length
;
618 cie
->output_sec
= sec
->output_section
;
620 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
622 /* Cannot handle unknown versions. */
623 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
624 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
626 strcpy (cie
->augmentation
, (char *) buf
);
627 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
628 ENSURE_NO_RELOCS (buf
);
629 if (buf
[0] == 'e' && buf
[1] == 'h')
631 /* GCC < 3.0 .eh_frame CIE */
632 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
633 is private to each CIE, so we don't need it for anything.
635 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
638 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
639 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
640 if (cie
->version
== 1)
643 cie
->ra_column
= *buf
++;
646 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
647 ENSURE_NO_RELOCS (buf
);
648 cie
->lsda_encoding
= DW_EH_PE_omit
;
649 cie
->fde_encoding
= DW_EH_PE_omit
;
650 cie
->per_encoding
= DW_EH_PE_omit
;
651 aug
= cie
->augmentation
;
652 if (aug
[0] != 'e' || aug
[1] != 'h')
657 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
658 ENSURE_NO_RELOCS (buf
);
665 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
666 ENSURE_NO_RELOCS (buf
);
667 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
670 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
671 ENSURE_NO_RELOCS (buf
);
672 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
680 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
681 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
684 if ((cie
->per_encoding
& 0xf0) == DW_EH_PE_aligned
)
686 length
= -(buf
- ehbuf
) & (per_width
- 1);
687 REQUIRE (skip_bytes (&buf
, end
, length
));
689 ENSURE_NO_RELOCS (buf
);
690 /* Ensure we have a reloc here. */
691 REQUIRE (GET_RELOC (buf
));
692 cie
->personality
.reloc_index
693 = cookie
->rel
- cookie
->rels
;
694 /* Cope with MIPS-style composite relocations. */
697 while (GET_RELOC (buf
) != NULL
);
698 REQUIRE (skip_bytes (&buf
, end
, per_width
));
702 /* Unrecognized augmentation. Better bail out. */
707 /* For shared libraries, try to get rid of as many RELATIVE relocs
710 && (get_elf_backend_data (abfd
)
711 ->elf_backend_can_make_relative_eh_frame
714 if ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
)
715 this_inf
->make_relative
= 1;
716 /* If the CIE doesn't already have an 'R' entry, it's fairly
717 easy to add one, provided that there's no aligned data
718 after the augmentation string. */
719 else if (cie
->fde_encoding
== DW_EH_PE_omit
720 && (cie
->per_encoding
& 0xf0) != DW_EH_PE_aligned
)
722 if (*cie
->augmentation
== 0)
723 this_inf
->add_augmentation_size
= 1;
724 this_inf
->u
.cie
.add_fde_encoding
= 1;
725 this_inf
->make_relative
= 1;
730 && (get_elf_backend_data (abfd
)
731 ->elf_backend_can_make_lsda_relative_eh_frame
733 && (cie
->lsda_encoding
& 0xf0) == DW_EH_PE_absptr
)
734 cie
->can_make_lsda_relative
= 1;
736 /* If FDE encoding was not specified, it defaults to
738 if (cie
->fde_encoding
== DW_EH_PE_omit
)
739 cie
->fde_encoding
= DW_EH_PE_absptr
;
741 initial_insn_length
= end
- buf
;
742 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
744 cie
->initial_insn_length
= initial_insn_length
;
745 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
748 buf
+= initial_insn_length
;
749 ENSURE_NO_RELOCS (buf
);
751 if (hdr_info
->merge_cies
)
752 this_inf
->u
.cie
.u
.full_cie
= cie
;
753 this_inf
->u
.cie
.per_encoding_relative
754 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
760 /* Find the corresponding CIE. */
761 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
762 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
763 if (cie_offset
== cie
->cie_inf
->offset
)
766 /* Ensure this FDE references one of the CIEs in this input
768 REQUIRE (cie
!= local_cies
+ cie_count
);
769 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
770 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
771 this_inf
->add_augmentation_size
772 = cie
->cie_inf
->add_augmentation_size
;
774 ENSURE_NO_RELOCS (buf
);
775 REQUIRE (GET_RELOC (buf
));
777 /* Chain together the FDEs for each section. */
778 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
779 /* RSEC will be NULL if FDE was cleared out as it was belonging to
780 a discarded SHT_GROUP. */
783 REQUIRE (rsec
->owner
== abfd
);
784 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
785 elf_fde_list (rsec
) = this_inf
;
788 /* Skip the initial location and address range. */
790 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
791 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
793 /* Skip the augmentation size, if present. */
794 if (cie
->augmentation
[0] == 'z')
795 REQUIRE (read_uleb128 (&buf
, end
, &length
));
799 /* Of the supported augmentation characters above, only 'L'
800 adds augmentation data to the FDE. This code would need to
801 be adjusted if any future augmentations do the same thing. */
802 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
805 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
806 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
807 this_inf
->lsda_offset
= buf
- start
;
808 /* If there's no 'z' augmentation, we don't know where the
809 CFA insns begin. Assume no padding. */
810 if (cie
->augmentation
[0] != 'z')
814 /* Skip over the augmentation data. */
815 REQUIRE (skip_bytes (&buf
, end
, length
));
818 buf
= last_fde
+ 4 + hdr_length
;
820 /* Cleared FDE? The instructions will not be cleared but verify all
821 the relocation entries for them are cleared. */
824 REQUIRE_CLEARED_RELOCS (buf
);
832 /* Try to interpret the CFA instructions and find the first
833 padding nop. Shrink this_inf's size so that it doesn't
834 include the padding. */
835 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
837 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
838 /* If we don't understand the CFA instructions, we can't know
839 what needs to be adjusted there. */
840 if (insns_end
== NULL
841 /* For the time being we don't support DW_CFA_set_loc in
843 || (set_loc_count
&& this_inf
->cie
))
845 this_inf
->size
-= end
- insns_end
;
846 if (insns_end
!= end
&& this_inf
->cie
)
848 cie
->initial_insn_length
-= end
- insns_end
;
849 cie
->length
-= end
- insns_end
;
852 && ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
853 || this_inf
->make_relative
))
858 this_inf
->set_loc
= bfd_malloc ((set_loc_count
+ 1)
859 * sizeof (unsigned int));
860 REQUIRE (this_inf
->set_loc
);
861 this_inf
->set_loc
[0] = set_loc_count
;
866 if (*p
== DW_CFA_set_loc
)
867 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
868 REQUIRE (skip_cfa_op (&p
, end
, length
));
872 this_inf
->removed
= 1;
873 this_inf
->fde_encoding
= cie
->fde_encoding
;
874 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
877 BFD_ASSERT (sec_info
->count
== num_entries
);
878 BFD_ASSERT (cie_count
== num_cies
);
880 elf_section_data (sec
)->sec_info
= sec_info
;
881 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
882 if (hdr_info
->merge_cies
)
884 sec_info
->cies
= local_cies
;
890 (*info
->callbacks
->einfo
)
891 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
893 hdr_info
->table
= FALSE
;
904 /* Finish a pass over all .eh_frame sections. */
907 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
909 struct eh_frame_hdr_info
*hdr_info
;
911 hdr_info
= &elf_hash_table (info
)->eh_info
;
912 hdr_info
->parsed_eh_frames
= TRUE
;
915 /* Mark all relocations against CIE or FDE ENT, which occurs in
916 .eh_frame section SEC. COOKIE describes the relocations in SEC;
917 its "rel" field can be changed freely. */
920 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
921 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
922 struct elf_reloc_cookie
*cookie
)
924 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
925 cookie
->rel
< cookie
->relend
926 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
928 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
934 /* Mark all the relocations against FDEs that relate to code in input
935 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
936 relocations are described by COOKIE. */
939 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
940 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
941 struct elf_reloc_cookie
*cookie
)
943 struct eh_cie_fde
*fde
, *cie
;
945 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
947 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
950 /* At this stage, all cie_inf fields point to local CIEs, so we
951 can use the same cookie to refer to them. */
952 cie
= fde
->u
.fde
.cie_inf
;
953 if (!cie
->u
.cie
.gc_mark
)
955 cie
->u
.cie
.gc_mark
= 1;
956 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
963 /* Input section SEC of ABFD is an .eh_frame section that contains the
964 CIE described by CIE_INF. Return a version of CIE_INF that is going
965 to be kept in the output, adding CIE_INF to the output if necessary.
967 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
968 relocations in REL. */
970 static struct eh_cie_fde
*
971 find_merged_cie (bfd
*abfd
, asection
*sec
,
972 struct eh_frame_hdr_info
*hdr_info
,
973 struct elf_reloc_cookie
*cookie
,
974 struct eh_cie_fde
*cie_inf
)
976 unsigned long r_symndx
;
977 struct cie
*cie
, *new_cie
;
978 Elf_Internal_Rela
*rel
;
981 /* Use CIE_INF if we have already decided to keep it. */
982 if (!cie_inf
->removed
)
985 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
986 if (cie_inf
->u
.cie
.merged
)
987 return cie_inf
->u
.cie
.u
.merged_with
;
989 cie
= cie_inf
->u
.cie
.u
.full_cie
;
991 /* Assume we will need to keep CIE_INF. */
992 cie_inf
->removed
= 0;
993 cie_inf
->u
.cie
.u
.sec
= sec
;
995 /* If we are not merging CIEs, use CIE_INF. */
999 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1001 /* Work out the address of personality routine, either as an absolute
1002 value or as a symbol. */
1003 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1004 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1006 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1007 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1010 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1011 if (r_symndx
>= cookie
->locsymcount
1012 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1014 struct elf_link_hash_entry
*h
;
1016 r_symndx
-= cookie
->extsymoff
;
1017 h
= cookie
->sym_hashes
[r_symndx
];
1019 while (h
->root
.type
== bfd_link_hash_indirect
1020 || h
->root
.type
== bfd_link_hash_warning
)
1021 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1023 cie
->personality
.h
= h
;
1027 Elf_Internal_Sym
*sym
;
1030 sym
= &cookie
->locsyms
[r_symndx
];
1031 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1032 if (sym_sec
== NULL
)
1035 if (sym_sec
->kept_section
!= NULL
)
1036 sym_sec
= sym_sec
->kept_section
;
1037 if (sym_sec
->output_section
== NULL
)
1040 cie
->local_personality
= 1;
1041 cie
->personality
.val
= (sym
->st_value
1042 + sym_sec
->output_offset
1043 + sym_sec
->output_section
->vma
);
1047 /* See if we can merge this CIE with an earlier one. */
1048 cie
->output_sec
= sec
->output_section
;
1049 cie_compute_hash (cie
);
1050 if (hdr_info
->cies
== NULL
)
1052 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1053 if (hdr_info
->cies
== NULL
)
1056 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
, cie
->hash
, INSERT
);
1060 new_cie
= (struct cie
*) *loc
;
1061 if (new_cie
== NULL
)
1063 /* Keep CIE_INF and record it in the hash table. */
1064 new_cie
= malloc (sizeof (struct cie
));
1065 if (new_cie
== NULL
)
1068 memcpy (new_cie
, cie
, sizeof (struct cie
));
1073 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1074 cie_inf
->removed
= 1;
1075 cie_inf
->u
.cie
.merged
= 1;
1076 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1077 if (cie_inf
->u
.cie
.make_lsda_relative
)
1078 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1080 return new_cie
->cie_inf
;
1083 /* This function is called for each input file before the .eh_frame
1084 section is relocated. It discards duplicate CIEs and FDEs for discarded
1085 functions. The function returns TRUE iff any entries have been
1089 _bfd_elf_discard_section_eh_frame
1090 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1091 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1092 struct elf_reloc_cookie
*cookie
)
1094 struct eh_cie_fde
*ent
;
1095 struct eh_frame_sec_info
*sec_info
;
1096 struct eh_frame_hdr_info
*hdr_info
;
1097 unsigned int ptr_size
, offset
;
1099 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1100 if (sec_info
== NULL
)
1103 hdr_info
= &elf_hash_table (info
)->eh_info
;
1104 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1106 /* There should only be one zero terminator, on the last input
1107 file supplying .eh_frame (crtend.o). Remove any others. */
1108 ent
->removed
= sec
->map_head
.s
!= NULL
;
1111 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1112 BFD_ASSERT (cookie
->rel
< cookie
->relend
1113 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1114 if (!(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
))
1117 && (((ent
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
1118 && ent
->make_relative
== 0)
1119 || (ent
->fde_encoding
& 0xf0) == DW_EH_PE_aligned
))
1121 /* If a shared library uses absolute pointers
1122 which we cannot turn into PC relative,
1123 don't create the binary search table,
1124 since it is affected by runtime relocations. */
1125 hdr_info
->table
= FALSE
;
1126 (*info
->callbacks
->einfo
)
1127 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1128 " table being created.\n"), abfd
, sec
);
1131 hdr_info
->fde_count
++;
1132 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, sec
, hdr_info
, cookie
,
1133 ent
->u
.fde
.cie_inf
);
1139 free (sec_info
->cies
);
1140 sec_info
->cies
= NULL
;
1143 ptr_size
= (get_elf_backend_data (sec
->owner
)
1144 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1146 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1149 ent
->new_offset
= offset
;
1150 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1153 sec
->rawsize
= sec
->size
;
1155 return offset
!= sec
->rawsize
;
1158 /* This function is called for .eh_frame_hdr section after
1159 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1160 input sections. It finalizes the size of .eh_frame_hdr section. */
1163 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1165 struct elf_link_hash_table
*htab
;
1166 struct eh_frame_hdr_info
*hdr_info
;
1169 htab
= elf_hash_table (info
);
1170 hdr_info
= &htab
->eh_info
;
1172 if (hdr_info
->cies
!= NULL
)
1174 htab_delete (hdr_info
->cies
);
1175 hdr_info
->cies
= NULL
;
1178 sec
= hdr_info
->hdr_sec
;
1182 sec
->size
= EH_FRAME_HDR_SIZE
;
1183 if (hdr_info
->table
)
1184 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1186 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1190 /* This function is called from size_dynamic_sections.
1191 It needs to decide whether .eh_frame_hdr should be output or not,
1192 because when the dynamic symbol table has been sized it is too late
1193 to strip sections. */
1196 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1200 struct elf_link_hash_table
*htab
;
1201 struct eh_frame_hdr_info
*hdr_info
;
1203 htab
= elf_hash_table (info
);
1204 hdr_info
= &htab
->eh_info
;
1205 if (hdr_info
->hdr_sec
== NULL
)
1208 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1210 hdr_info
->hdr_sec
= NULL
;
1215 if (info
->eh_frame_hdr
)
1216 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1218 /* Count only sections which have at least a single CIE or FDE.
1219 There cannot be any CIE or FDE <= 8 bytes. */
1220 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1221 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1227 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1228 hdr_info
->hdr_sec
= NULL
;
1232 hdr_info
->table
= TRUE
;
1236 /* Adjust an address in the .eh_frame section. Given OFFSET within
1237 SEC, this returns the new offset in the adjusted .eh_frame section,
1238 or -1 if the address refers to a CIE/FDE which has been removed
1239 or to offset with dynamic relocation which is no longer needed. */
1242 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1243 struct bfd_link_info
*info
,
1247 struct eh_frame_sec_info
*sec_info
;
1248 struct elf_link_hash_table
*htab
;
1249 struct eh_frame_hdr_info
*hdr_info
;
1250 unsigned int lo
, hi
, mid
;
1252 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1254 sec_info
= elf_section_data (sec
)->sec_info
;
1256 if (offset
>= sec
->rawsize
)
1257 return offset
- sec
->rawsize
+ sec
->size
;
1259 htab
= elf_hash_table (info
);
1260 hdr_info
= &htab
->eh_info
;
1263 hi
= sec_info
->count
;
1267 mid
= (lo
+ hi
) / 2;
1268 if (offset
< sec_info
->entry
[mid
].offset
)
1271 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1277 BFD_ASSERT (lo
< hi
);
1279 /* FDE or CIE was removed. */
1280 if (sec_info
->entry
[mid
].removed
)
1281 return (bfd_vma
) -1;
1283 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1284 relocation against FDE's initial_location field. */
1285 if (!sec_info
->entry
[mid
].cie
1286 && sec_info
->entry
[mid
].make_relative
1287 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1288 return (bfd_vma
) -2;
1290 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1291 for run-time relocation against LSDA field. */
1292 if (!sec_info
->entry
[mid
].cie
1293 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1294 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1295 + sec_info
->entry
[mid
].lsda_offset
))
1296 return (bfd_vma
) -2;
1298 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1299 relocation against DW_CFA_set_loc's arguments. */
1300 if (sec_info
->entry
[mid
].set_loc
1301 && sec_info
->entry
[mid
].make_relative
1302 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1303 + sec_info
->entry
[mid
].set_loc
[1]))
1307 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1308 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1309 + sec_info
->entry
[mid
].set_loc
[cnt
])
1310 return (bfd_vma
) -2;
1313 /* Any new augmentation bytes go before the first relocation. */
1314 return (offset
+ sec_info
->entry
[mid
].new_offset
1315 - sec_info
->entry
[mid
].offset
1316 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1317 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1320 /* Write out .eh_frame section. This is called with the relocated
1324 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1325 struct bfd_link_info
*info
,
1329 struct eh_frame_sec_info
*sec_info
;
1330 struct elf_link_hash_table
*htab
;
1331 struct eh_frame_hdr_info
*hdr_info
;
1332 unsigned int ptr_size
;
1333 struct eh_cie_fde
*ent
;
1335 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1336 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1337 sec
->output_offset
, sec
->size
);
1339 ptr_size
= (get_elf_backend_data (abfd
)
1340 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1341 BFD_ASSERT (ptr_size
!= 0);
1343 sec_info
= elf_section_data (sec
)->sec_info
;
1344 htab
= elf_hash_table (info
);
1345 hdr_info
= &htab
->eh_info
;
1347 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1349 = bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1350 if (hdr_info
->array
== NULL
)
1353 /* The new offsets can be bigger or smaller than the original offsets.
1354 We therefore need to make two passes over the section: one backward
1355 pass to move entries up and one forward pass to move entries down.
1356 The two passes won't interfere with each other because entries are
1358 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1359 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1360 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1362 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1363 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1364 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1366 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1368 unsigned char *buf
, *end
;
1369 unsigned int new_size
;
1376 /* Any terminating FDE must be at the end of the section. */
1377 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1381 buf
= contents
+ ent
->new_offset
;
1382 end
= buf
+ ent
->size
;
1383 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1385 /* Update the size. It may be shrinked. */
1386 bfd_put_32 (abfd
, new_size
- 4, buf
);
1388 /* Filling the extra bytes with DW_CFA_nops. */
1389 if (new_size
!= ent
->size
)
1390 memset (end
, 0, new_size
- ent
->size
);
1395 if (ent
->make_relative
1396 || ent
->u
.cie
.make_lsda_relative
1397 || ent
->u
.cie
.per_encoding_relative
)
1400 unsigned int action
, extra_string
, extra_data
;
1401 unsigned int per_width
, per_encoding
;
1403 /* Need to find 'R' or 'L' augmentation's argument and modify
1404 DW_EH_PE_* value. */
1405 action
= ((ent
->make_relative
? 1 : 0)
1406 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1407 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1408 extra_string
= extra_augmentation_string_bytes (ent
);
1409 extra_data
= extra_augmentation_data_bytes (ent
);
1411 /* Skip length, id and version. */
1414 buf
+= strlen (aug
) + 1;
1415 skip_leb128 (&buf
, end
);
1416 skip_leb128 (&buf
, end
);
1417 skip_leb128 (&buf
, end
);
1420 /* The uleb128 will always be a single byte for the kind
1421 of augmentation strings that we're prepared to handle. */
1422 *buf
++ += extra_data
;
1426 /* Make room for the new augmentation string and data bytes. */
1427 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1428 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1429 buf
+= extra_string
;
1430 end
+= extra_string
+ extra_data
;
1432 if (ent
->add_augmentation_size
)
1435 *buf
++ = extra_data
- 1;
1437 if (ent
->u
.cie
.add_fde_encoding
)
1439 BFD_ASSERT (action
& 1);
1441 *buf
++ = DW_EH_PE_pcrel
;
1451 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1452 *buf
|= DW_EH_PE_pcrel
;
1458 per_encoding
= *buf
++;
1459 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1460 BFD_ASSERT (per_width
!= 0);
1461 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1462 == ent
->u
.cie
.per_encoding_relative
);
1463 if ((per_encoding
& 0xf0) == DW_EH_PE_aligned
)
1465 + ((buf
- contents
+ per_width
- 1)
1466 & ~((bfd_size_type
) per_width
- 1)));
1471 val
= read_value (abfd
, buf
, per_width
,
1472 get_DW_EH_PE_signed (per_encoding
));
1473 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1474 val
-= extra_string
+ extra_data
;
1475 write_value (abfd
, buf
, val
, per_width
);
1483 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1484 *buf
|= DW_EH_PE_pcrel
;
1499 bfd_vma value
, address
;
1502 struct eh_cie_fde
*cie
;
1505 cie
= ent
->u
.fde
.cie_inf
;
1507 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1508 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1509 bfd_put_32 (abfd
, value
, buf
);
1511 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1512 value
= read_value (abfd
, buf
, width
,
1513 get_DW_EH_PE_signed (ent
->fde_encoding
));
1517 switch (ent
->fde_encoding
& 0xf0)
1519 case DW_EH_PE_indirect
:
1520 case DW_EH_PE_textrel
:
1521 BFD_ASSERT (hdr_info
== NULL
);
1523 case DW_EH_PE_datarel
:
1525 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1527 BFD_ASSERT (got
!= NULL
);
1528 address
+= got
->vma
;
1531 case DW_EH_PE_pcrel
:
1532 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1533 address
+= (sec
->output_section
->vma
1534 + sec
->output_offset
1538 if (ent
->make_relative
)
1539 value
-= (sec
->output_section
->vma
1540 + sec
->output_offset
1541 + ent
->new_offset
+ 8);
1542 write_value (abfd
, buf
, value
, width
);
1549 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1550 hdr_info
->array
[hdr_info
->array_count
++].fde
1551 = (sec
->output_section
->vma
1552 + sec
->output_offset
1556 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
1557 || cie
->u
.cie
.make_lsda_relative
)
1559 buf
+= ent
->lsda_offset
;
1560 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1561 value
= read_value (abfd
, buf
, width
,
1562 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1565 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1566 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1567 else if (cie
->u
.cie
.make_lsda_relative
)
1568 value
-= (sec
->output_section
->vma
1569 + sec
->output_offset
1570 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1571 write_value (abfd
, buf
, value
, width
);
1574 else if (ent
->add_augmentation_size
)
1576 /* Skip the PC and length and insert a zero byte for the
1577 augmentation size. */
1579 memmove (buf
+ 1, buf
, end
- buf
);
1585 /* Adjust DW_CFA_set_loc. */
1586 unsigned int cnt
, width
;
1589 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1590 new_offset
= ent
->new_offset
+ 8
1591 + extra_augmentation_string_bytes (ent
)
1592 + extra_augmentation_data_bytes (ent
);
1594 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1597 buf
= start
+ ent
->set_loc
[cnt
];
1599 value
= read_value (abfd
, buf
, width
,
1600 get_DW_EH_PE_signed (ent
->fde_encoding
));
1604 if ((ent
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1605 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
1606 if (ent
->make_relative
)
1607 value
-= (sec
->output_section
->vma
1608 + sec
->output_offset
1609 + new_offset
+ ent
->set_loc
[cnt
]);
1610 write_value (abfd
, buf
, value
, width
);
1616 /* We don't align the section to its section alignment since the
1617 runtime library only expects all CIE/FDE records aligned at
1618 the pointer size. _bfd_elf_discard_section_eh_frame should
1619 have padded CIE/FDE records to multiple of pointer size with
1620 size_of_output_cie_fde. */
1621 if ((sec
->size
% ptr_size
) != 0)
1624 return bfd_set_section_contents (abfd
, sec
->output_section
,
1625 contents
, (file_ptr
) sec
->output_offset
,
1629 /* Helper function used to sort .eh_frame_hdr search table by increasing
1630 VMA of FDE initial location. */
1633 vma_compare (const void *a
, const void *b
)
1635 const struct eh_frame_array_ent
*p
= a
;
1636 const struct eh_frame_array_ent
*q
= b
;
1637 if (p
->initial_loc
> q
->initial_loc
)
1639 if (p
->initial_loc
< q
->initial_loc
)
1644 /* Write out .eh_frame_hdr section. This must be called after
1645 _bfd_elf_write_section_eh_frame has been called on all input
1647 .eh_frame_hdr format:
1648 ubyte version (currently 1)
1649 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1651 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1652 number (or DW_EH_PE_omit if there is no
1653 binary search table computed))
1654 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1655 or DW_EH_PE_omit if not present.
1656 DW_EH_PE_datarel is using address of
1657 .eh_frame_hdr section start as base)
1658 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1659 optionally followed by:
1660 [encoded] fde_count (total number of FDEs in .eh_frame section)
1661 fde_count x [encoded] initial_loc, fde
1662 (array of encoded pairs containing
1663 FDE initial_location field and FDE address,
1664 sorted by increasing initial_loc). */
1667 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1669 struct elf_link_hash_table
*htab
;
1670 struct eh_frame_hdr_info
*hdr_info
;
1673 asection
*eh_frame_sec
;
1676 bfd_vma encoded_eh_frame
;
1678 htab
= elf_hash_table (info
);
1679 hdr_info
= &htab
->eh_info
;
1680 sec
= hdr_info
->hdr_sec
;
1684 size
= EH_FRAME_HDR_SIZE
;
1685 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1686 size
+= 4 + hdr_info
->fde_count
* 8;
1687 contents
= bfd_malloc (size
);
1688 if (contents
== NULL
)
1691 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1692 if (eh_frame_sec
== NULL
)
1698 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1699 contents
[0] = 1; /* Version. */
1700 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1701 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1702 &encoded_eh_frame
); /* .eh_frame offset. */
1704 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1706 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1707 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1711 contents
[2] = DW_EH_PE_omit
;
1712 contents
[3] = DW_EH_PE_omit
;
1714 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1716 if (contents
[2] != DW_EH_PE_omit
)
1720 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1721 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1723 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1726 hdr_info
->array
[i
].initial_loc
1727 - sec
->output_section
->vma
,
1728 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1730 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1731 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1735 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1736 contents
, (file_ptr
) sec
->output_offset
,
1742 /* Return the width of FDE addresses. This is the default implementation. */
1745 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1747 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1750 /* Decide whether we can use a PC-relative encoding within the given
1751 EH frame section. This is the default implementation. */
1754 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1755 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1756 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1761 /* Select an encoding for the given address. Preference is given to
1762 PC-relative addressing modes. */
1765 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1766 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1767 asection
*osec
, bfd_vma offset
,
1768 asection
*loc_sec
, bfd_vma loc_offset
,
1771 *encoded
= osec
->vma
+ offset
-
1772 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1773 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;