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 2 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, MA 02110-1301, USA. */
26 #include "elf/dwarf2.h"
28 #define EH_FRAME_HDR_SIZE 8
34 unsigned char version
;
35 char augmentation
[20];
37 bfd_signed_vma data_align
;
39 bfd_vma augmentation_size
;
40 struct elf_link_hash_entry
*personality
;
42 struct eh_cie_fde
*cie_inf
;
43 unsigned char per_encoding
;
44 unsigned char lsda_encoding
;
45 unsigned char fde_encoding
;
46 unsigned char initial_insn_length
;
47 unsigned char make_relative
;
48 unsigned char make_lsda_relative
;
49 unsigned char initial_instructions
[50];
54 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
55 move onto the next byte. Return true on success. */
57 static inline bfd_boolean
58 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
62 *result
= *((*iter
)++);
66 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
67 Return true it was possible to move LENGTH bytes. */
69 static inline bfd_boolean
70 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
72 if ((bfd_size_type
) (end
- *iter
) < length
)
81 /* Move *ITER over an leb128, stopping at END. Return true if the end
82 of the leb128 was found. */
85 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
89 if (!read_byte (iter
, end
, &byte
))
95 /* Like skip_leb128, but treat the leb128 as an unsigned value and
96 store it in *VALUE. */
99 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
104 if (!skip_leb128 (iter
, end
))
110 *value
= (*value
<< 7) | (*--p
& 0x7f);
115 /* Like read_uleb128, but for signed values. */
118 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
123 if (!skip_leb128 (iter
, end
))
127 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
129 *value
= (*value
<< 7) | (*--p
& 0x7f);
134 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
137 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
139 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
141 if ((encoding
& 0x60) == 0x60)
144 switch (encoding
& 7)
146 case DW_EH_PE_udata2
: return 2;
147 case DW_EH_PE_udata4
: return 4;
148 case DW_EH_PE_udata8
: return 8;
149 case DW_EH_PE_absptr
: return ptr_size
;
157 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
159 /* Read a width sized value from memory. */
162 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
170 value
= bfd_get_signed_16 (abfd
, buf
);
172 value
= bfd_get_16 (abfd
, buf
);
176 value
= bfd_get_signed_32 (abfd
, buf
);
178 value
= bfd_get_32 (abfd
, buf
);
182 value
= bfd_get_signed_64 (abfd
, buf
);
184 value
= bfd_get_64 (abfd
, buf
);
194 /* Store a width sized value to memory. */
197 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
201 case 2: bfd_put_16 (abfd
, value
, buf
); break;
202 case 4: bfd_put_32 (abfd
, value
, buf
); break;
203 case 8: bfd_put_64 (abfd
, value
, buf
); break;
204 default: BFD_FAIL ();
208 /* Return one if C1 and C2 CIEs can be merged. */
211 cie_eq (const void *e1
, const void *e2
)
213 const struct cie
*c1
= e1
;
214 const struct cie
*c2
= e2
;
216 if (c1
->hash
== c2
->hash
217 && c1
->length
== c2
->length
218 && c1
->version
== c2
->version
219 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
220 && strcmp (c1
->augmentation
, "eh") != 0
221 && c1
->code_align
== c2
->code_align
222 && c1
->data_align
== c2
->data_align
223 && c1
->ra_column
== c2
->ra_column
224 && c1
->augmentation_size
== c2
->augmentation_size
225 && c1
->personality
== c2
->personality
226 && c1
->output_sec
== c2
->output_sec
227 && c1
->per_encoding
== c2
->per_encoding
228 && c1
->lsda_encoding
== c2
->lsda_encoding
229 && c1
->fde_encoding
== c2
->fde_encoding
230 && c1
->initial_insn_length
== c2
->initial_insn_length
231 && memcmp (c1
->initial_instructions
,
232 c2
->initial_instructions
,
233 c1
->initial_insn_length
) == 0)
240 cie_hash (const void *e
)
242 const struct cie
*c
= e
;
247 cie_compute_hash (struct cie
*c
)
250 h
= iterative_hash_object (c
->length
, h
);
251 h
= iterative_hash_object (c
->version
, h
);
252 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
253 h
= iterative_hash_object (c
->code_align
, h
);
254 h
= iterative_hash_object (c
->data_align
, h
);
255 h
= iterative_hash_object (c
->ra_column
, h
);
256 h
= iterative_hash_object (c
->augmentation_size
, h
);
257 h
= iterative_hash_object (c
->personality
, h
);
258 h
= iterative_hash_object (c
->output_sec
, h
);
259 h
= iterative_hash_object (c
->per_encoding
, h
);
260 h
= iterative_hash_object (c
->lsda_encoding
, h
);
261 h
= iterative_hash_object (c
->fde_encoding
, h
);
262 h
= iterative_hash_object (c
->initial_insn_length
, h
);
263 h
= iterative_hash (c
->initial_instructions
, c
->initial_insn_length
, h
);
268 /* Return the number of extra bytes that we'll be inserting into
269 ENTRY's augmentation string. */
271 static INLINE
unsigned int
272 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
274 unsigned int size
= 0;
277 if (entry
->add_augmentation_size
)
279 if (entry
->add_fde_encoding
)
285 /* Likewise ENTRY's augmentation data. */
287 static INLINE
unsigned int
288 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
290 unsigned int size
= 0;
293 if (entry
->add_augmentation_size
)
295 if (entry
->add_fde_encoding
)
300 if (entry
->cie_inf
->add_augmentation_size
)
306 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
307 required alignment of ENTRY in bytes. */
310 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
314 if (entry
->size
== 4)
317 + extra_augmentation_string_bytes (entry
)
318 + extra_augmentation_data_bytes (entry
)
319 + alignment
- 1) & -alignment
;
322 /* Assume that the bytes between *ITER and END are CFA instructions.
323 Try to move *ITER past the first instruction and return true on
324 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
327 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
332 if (!read_byte (iter
, end
, &op
))
335 switch (op
& 0xc0 ? op
& 0xc0 : op
)
338 case DW_CFA_advance_loc
:
340 case DW_CFA_remember_state
:
341 case DW_CFA_restore_state
:
342 case DW_CFA_GNU_window_save
:
347 case DW_CFA_restore_extended
:
348 case DW_CFA_undefined
:
349 case DW_CFA_same_value
:
350 case DW_CFA_def_cfa_register
:
351 case DW_CFA_def_cfa_offset
:
352 case DW_CFA_def_cfa_offset_sf
:
353 case DW_CFA_GNU_args_size
:
354 /* One leb128 argument. */
355 return skip_leb128 (iter
, end
);
357 case DW_CFA_val_offset
:
358 case DW_CFA_val_offset_sf
:
359 case DW_CFA_offset_extended
:
360 case DW_CFA_register
:
362 case DW_CFA_offset_extended_sf
:
363 case DW_CFA_GNU_negative_offset_extended
:
364 case DW_CFA_def_cfa_sf
:
365 /* Two leb128 arguments. */
366 return (skip_leb128 (iter
, end
)
367 && skip_leb128 (iter
, end
));
369 case DW_CFA_def_cfa_expression
:
370 /* A variable-length argument. */
371 return (read_uleb128 (iter
, end
, &length
)
372 && skip_bytes (iter
, end
, length
));
374 case DW_CFA_expression
:
375 case DW_CFA_val_expression
:
376 /* A leb128 followed by a variable-length argument. */
377 return (skip_leb128 (iter
, end
)
378 && read_uleb128 (iter
, end
, &length
)
379 && skip_bytes (iter
, end
, length
));
382 return skip_bytes (iter
, end
, encoded_ptr_width
);
384 case DW_CFA_advance_loc1
:
385 return skip_bytes (iter
, end
, 1);
387 case DW_CFA_advance_loc2
:
388 return skip_bytes (iter
, end
, 2);
390 case DW_CFA_advance_loc4
:
391 return skip_bytes (iter
, end
, 4);
393 case DW_CFA_MIPS_advance_loc8
:
394 return skip_bytes (iter
, end
, 8);
401 /* Try to interpret the bytes between BUF and END as CFA instructions.
402 If every byte makes sense, return a pointer to the first DW_CFA_nop
403 padding byte, or END if there is no padding. Return null otherwise.
404 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
407 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
408 unsigned int *set_loc_count
)
414 if (*buf
== DW_CFA_nop
)
418 if (*buf
== DW_CFA_set_loc
)
420 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
427 /* This function is called for each input file before the .eh_frame
428 section is relocated. It discards duplicate CIEs and FDEs for discarded
429 functions. The function returns TRUE iff any entries have been
433 _bfd_elf_discard_section_eh_frame
434 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
435 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
436 struct elf_reloc_cookie
*cookie
)
438 #define REQUIRE(COND) \
441 goto free_no_table; \
444 bfd_byte
*ehbuf
= NULL
, *buf
;
446 struct eh_cie_fde
*ent
, *this_inf
;
447 unsigned int hdr_length
, hdr_id
;
452 unsigned int usage_count
;
454 } *ecies
= NULL
, *ecie
;
455 unsigned int ecie_count
= 0, ecie_alloced
= 0;
457 struct elf_link_hash_table
*htab
;
458 struct eh_frame_hdr_info
*hdr_info
;
459 struct eh_frame_sec_info
*sec_info
= NULL
;
461 unsigned int ptr_size
;
462 unsigned int entry_alloced
;
466 /* This file does not contain .eh_frame information. */
470 if (bfd_is_abs_section (sec
->output_section
))
472 /* At least one of the sections is being discarded from the
473 link, so we should just ignore them. */
477 htab
= elf_hash_table (info
);
478 hdr_info
= &htab
->eh_info
;
480 if (hdr_info
->cies
== NULL
&& !info
->relocatable
)
481 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
483 /* Read the frame unwind information from abfd. */
485 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
488 && bfd_get_32 (abfd
, ehbuf
) == 0
489 && cookie
->rel
== cookie
->relend
)
491 /* Empty .eh_frame section. */
496 /* If .eh_frame section size doesn't fit into int, we cannot handle
497 it (it would need to use 64-bit .eh_frame format anyway). */
498 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
500 ptr_size
= (get_elf_backend_data (abfd
)
501 ->elf_backend_eh_frame_address_size (abfd
, sec
));
502 REQUIRE (ptr_size
!= 0);
505 sec_info
= bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
506 + 99 * sizeof (struct eh_cie_fde
));
511 #define ENSURE_NO_RELOCS(buf) \
512 REQUIRE (!(cookie->rel < cookie->relend \
513 && (cookie->rel->r_offset \
514 < (bfd_size_type) ((buf) - ehbuf)) \
515 && cookie->rel->r_info != 0))
517 #define SKIP_RELOCS(buf) \
518 while (cookie->rel < cookie->relend \
519 && (cookie->rel->r_offset \
520 < (bfd_size_type) ((buf) - ehbuf))) \
523 #define GET_RELOC(buf) \
524 ((cookie->rel < cookie->relend \
525 && (cookie->rel->r_offset \
526 == (bfd_size_type) ((buf) - ehbuf))) \
527 ? cookie->rel : NULL)
532 bfd_byte
*start
, *end
, *insns
, *insns_end
;
533 bfd_size_type length
;
534 unsigned int set_loc_count
;
536 if (sec_info
->count
== entry_alloced
)
538 sec_info
= bfd_realloc (sec_info
,
539 sizeof (struct eh_frame_sec_info
)
540 + ((entry_alloced
+ 99)
541 * sizeof (struct eh_cie_fde
)));
544 memset (&sec_info
->entry
[entry_alloced
], 0,
545 100 * sizeof (struct eh_cie_fde
));
546 entry_alloced
+= 100;
549 this_inf
= sec_info
->entry
+ sec_info
->count
;
552 if ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
)
555 /* Read the length of the entry. */
556 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
557 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
559 /* 64-bit .eh_frame is not supported. */
560 REQUIRE (hdr_length
!= 0xffffffff);
562 /* The CIE/FDE must be fully contained in this input section. */
563 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
564 end
= buf
+ hdr_length
;
566 this_inf
->offset
= last_fde
- ehbuf
;
567 this_inf
->size
= 4 + hdr_length
;
571 /* A zero-length CIE should only be found at the end of
573 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
574 ENSURE_NO_RELOCS (buf
);
579 REQUIRE (skip_bytes (&buf
, end
, 4));
580 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
584 unsigned int initial_insn_length
;
589 if (ecie_count
== ecie_alloced
)
591 ecies
= bfd_realloc (ecies
,
592 (ecie_alloced
+ 20) * sizeof (*ecies
));
594 memset (&ecies
[ecie_alloced
], 0, 20 * sizeof (*ecies
));
598 cie
= &ecies
[ecie_count
].cie
;
599 ecies
[ecie_count
].offset
= this_inf
->offset
;
600 ecies
[ecie_count
++].entry
= sec_info
->count
;
601 cie
->length
= hdr_length
;
603 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
605 /* Cannot handle unknown versions. */
606 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
607 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
609 strcpy (cie
->augmentation
, (char *) buf
);
610 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
611 ENSURE_NO_RELOCS (buf
);
612 if (buf
[0] == 'e' && buf
[1] == 'h')
614 /* GCC < 3.0 .eh_frame CIE */
615 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
616 is private to each CIE, so we don't need it for anything.
618 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
621 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
622 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
623 if (cie
->version
== 1)
626 cie
->ra_column
= *buf
++;
629 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
630 ENSURE_NO_RELOCS (buf
);
631 cie
->lsda_encoding
= DW_EH_PE_omit
;
632 cie
->fde_encoding
= DW_EH_PE_omit
;
633 cie
->per_encoding
= DW_EH_PE_omit
;
634 aug
= cie
->augmentation
;
635 if (aug
[0] != 'e' || aug
[1] != 'h')
640 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
641 ENSURE_NO_RELOCS (buf
);
648 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
649 ENSURE_NO_RELOCS (buf
);
650 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
653 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
654 ENSURE_NO_RELOCS (buf
);
655 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
663 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
664 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
667 if ((cie
->per_encoding
& 0xf0) == DW_EH_PE_aligned
)
669 length
= -(buf
- ehbuf
) & (per_width
- 1);
670 REQUIRE (skip_bytes (&buf
, end
, length
));
672 ENSURE_NO_RELOCS (buf
);
673 /* Ensure we have a reloc here, against
675 if (GET_RELOC (buf
) != NULL
)
677 unsigned long r_symndx
;
681 r_symndx
= ELF64_R_SYM (cookie
->rel
->r_info
);
684 r_symndx
= ELF32_R_SYM (cookie
->rel
->r_info
);
685 if (r_symndx
>= cookie
->locsymcount
)
687 struct elf_link_hash_entry
*h
;
689 r_symndx
-= cookie
->extsymoff
;
690 h
= cookie
->sym_hashes
[r_symndx
];
692 while (h
->root
.type
== bfd_link_hash_indirect
693 || h
->root
.type
== bfd_link_hash_warning
)
694 h
= (struct elf_link_hash_entry
*)
697 cie
->personality
= h
;
699 /* Cope with MIPS-style composite relocations. */
702 while (GET_RELOC (buf
) != NULL
);
704 REQUIRE (skip_bytes (&buf
, end
, per_width
));
705 REQUIRE (cie
->personality
);
709 /* Unrecognized augmentation. Better bail out. */
714 /* For shared libraries, try to get rid of as many RELATIVE relocs
717 && (get_elf_backend_data (abfd
)
718 ->elf_backend_can_make_relative_eh_frame
721 if ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
)
722 cie
->make_relative
= 1;
723 /* If the CIE doesn't already have an 'R' entry, it's fairly
724 easy to add one, provided that there's no aligned data
725 after the augmentation string. */
726 else if (cie
->fde_encoding
== DW_EH_PE_omit
727 && (cie
->per_encoding
& 0xf0) != DW_EH_PE_aligned
)
729 if (*cie
->augmentation
== 0)
730 this_inf
->add_augmentation_size
= 1;
731 this_inf
->add_fde_encoding
= 1;
732 cie
->make_relative
= 1;
737 && (get_elf_backend_data (abfd
)
738 ->elf_backend_can_make_lsda_relative_eh_frame
740 && (cie
->lsda_encoding
& 0xf0) == DW_EH_PE_absptr
)
741 cie
->make_lsda_relative
= 1;
743 /* If FDE encoding was not specified, it defaults to
745 if (cie
->fde_encoding
== DW_EH_PE_omit
)
746 cie
->fde_encoding
= DW_EH_PE_absptr
;
748 initial_insn_length
= end
- buf
;
749 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
751 cie
->initial_insn_length
= initial_insn_length
;
752 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
755 buf
+= initial_insn_length
;
756 ENSURE_NO_RELOCS (buf
);
760 /* Find the corresponding CIE. */
761 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
762 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
763 if (cie_offset
== ecie
->offset
)
766 /* Ensure this FDE references one of the CIEs in this input
768 REQUIRE (ecie
!= ecies
+ ecie_count
);
771 ENSURE_NO_RELOCS (buf
);
772 REQUIRE (GET_RELOC (buf
));
774 if ((*reloc_symbol_deleted_p
) (buf
- ehbuf
, cookie
))
775 /* This is a FDE against a discarded section. It should
777 this_inf
->removed
= 1;
781 && (((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
782 && cie
->make_relative
== 0)
783 || (cie
->fde_encoding
& 0xf0) == DW_EH_PE_aligned
))
785 /* If a shared library uses absolute pointers
786 which we cannot turn into PC relative,
787 don't create the binary search table,
788 since it is affected by runtime relocations. */
789 hdr_info
->table
= FALSE
;
790 (*info
->callbacks
->einfo
)
791 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
792 " table being created.\n"), abfd
, sec
);
795 hdr_info
->fde_count
++;
796 this_inf
->cie_inf
= (void *) (ecie
- ecies
);
799 /* Skip the initial location and address range. */
801 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
802 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
804 /* Skip the augmentation size, if present. */
805 if (cie
->augmentation
[0] == 'z')
806 REQUIRE (read_uleb128 (&buf
, end
, &length
));
810 /* Of the supported augmentation characters above, only 'L'
811 adds augmentation data to the FDE. This code would need to
812 be adjusted if any future augmentations do the same thing. */
813 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
815 this_inf
->lsda_offset
= buf
- start
;
816 /* If there's no 'z' augmentation, we don't know where the
817 CFA insns begin. Assume no padding. */
818 if (cie
->augmentation
[0] != 'z')
822 /* Skip over the augmentation data. */
823 REQUIRE (skip_bytes (&buf
, end
, length
));
826 buf
= last_fde
+ 4 + hdr_length
;
830 /* Try to interpret the CFA instructions and find the first
831 padding nop. Shrink this_inf's size so that it doesn't
832 include the padding. */
833 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
835 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
836 /* If we don't understand the CFA instructions, we can't know
837 what needs to be adjusted there. */
838 if (insns_end
== NULL
839 /* For the time being we don't support DW_CFA_set_loc in
841 || (set_loc_count
&& this_inf
->cie
))
843 this_inf
->size
-= end
- insns_end
;
844 if (insns_end
!= end
&& this_inf
->cie
)
846 cie
->initial_insn_length
-= end
- insns_end
;
847 cie
->length
-= end
- insns_end
;
850 && ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
851 || cie
->make_relative
))
856 this_inf
->set_loc
= bfd_malloc ((set_loc_count
+ 1)
857 * sizeof (unsigned int));
858 REQUIRE (this_inf
->set_loc
);
859 this_inf
->set_loc
[0] = set_loc_count
;
864 if (*p
== DW_CFA_set_loc
)
865 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
866 REQUIRE (skip_cfa_op (&p
, end
, length
));
870 this_inf
->fde_encoding
= cie
->fde_encoding
;
871 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
875 elf_section_data (sec
)->sec_info
= sec_info
;
876 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
878 /* Look at all CIEs in this section and determine which can be
879 removed as unused, which can be merged with previous duplicate
880 CIEs and which need to be kept. */
881 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
883 if (ecie
->usage_count
== 0)
885 sec_info
->entry
[ecie
->entry
].removed
= 1;
888 ecie
->cie
.output_sec
= sec
->output_section
;
889 ecie
->cie
.cie_inf
= sec_info
->entry
+ ecie
->entry
;
890 cie_compute_hash (&ecie
->cie
);
891 if (hdr_info
->cies
!= NULL
)
893 void **loc
= htab_find_slot_with_hash (hdr_info
->cies
, &ecie
->cie
,
894 ecie
->cie
.hash
, INSERT
);
897 if (*loc
!= HTAB_EMPTY_ENTRY
)
899 sec_info
->entry
[ecie
->entry
].removed
= 1;
900 ecie
->cie
.cie_inf
= ((struct cie
*) *loc
)->cie_inf
;
904 *loc
= malloc (sizeof (struct cie
));
906 *loc
= HTAB_DELETED_ENTRY
;
908 memcpy (*loc
, &ecie
->cie
, sizeof (struct cie
));
911 ecie
->cie
.cie_inf
->make_relative
= ecie
->cie
.make_relative
;
912 ecie
->cie
.cie_inf
->make_lsda_relative
= ecie
->cie
.make_lsda_relative
;
913 ecie
->cie
.cie_inf
->per_encoding_relative
914 = (ecie
->cie
.per_encoding
& 0x70) == DW_EH_PE_pcrel
;
917 /* Ok, now we can assign new offsets. */
919 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
924 ecie
= ecies
+ (unsigned long) ent
->cie_inf
;
925 ent
->cie_inf
= ecie
->cie
.cie_inf
;
927 ent
->new_offset
= offset
;
928 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
931 /* Resize the sec as needed. */
932 sec
->rawsize
= sec
->size
;
938 return offset
!= sec
->rawsize
;
941 (*info
->callbacks
->einfo
)
942 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
950 hdr_info
->table
= FALSE
;
956 /* This function is called for .eh_frame_hdr section after
957 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
958 input sections. It finalizes the size of .eh_frame_hdr section. */
961 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
963 struct elf_link_hash_table
*htab
;
964 struct eh_frame_hdr_info
*hdr_info
;
967 htab
= elf_hash_table (info
);
968 hdr_info
= &htab
->eh_info
;
970 if (hdr_info
->cies
!= NULL
)
972 htab_delete (hdr_info
->cies
);
973 hdr_info
->cies
= NULL
;
976 sec
= hdr_info
->hdr_sec
;
980 sec
->size
= EH_FRAME_HDR_SIZE
;
982 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
984 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
988 /* This function is called from size_dynamic_sections.
989 It needs to decide whether .eh_frame_hdr should be output or not,
990 because when the dynamic symbol table has been sized it is too late
991 to strip sections. */
994 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
998 struct elf_link_hash_table
*htab
;
999 struct eh_frame_hdr_info
*hdr_info
;
1001 htab
= elf_hash_table (info
);
1002 hdr_info
= &htab
->eh_info
;
1003 if (hdr_info
->hdr_sec
== NULL
)
1006 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1008 hdr_info
->hdr_sec
= NULL
;
1013 if (info
->eh_frame_hdr
)
1014 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1016 /* Count only sections which have at least a single CIE or FDE.
1017 There cannot be any CIE or FDE <= 8 bytes. */
1018 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1019 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1025 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1026 hdr_info
->hdr_sec
= NULL
;
1030 hdr_info
->table
= TRUE
;
1034 /* Adjust an address in the .eh_frame section. Given OFFSET within
1035 SEC, this returns the new offset in the adjusted .eh_frame section,
1036 or -1 if the address refers to a CIE/FDE which has been removed
1037 or to offset with dynamic relocation which is no longer needed. */
1040 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1041 struct bfd_link_info
*info
,
1045 struct eh_frame_sec_info
*sec_info
;
1046 struct elf_link_hash_table
*htab
;
1047 struct eh_frame_hdr_info
*hdr_info
;
1048 unsigned int lo
, hi
, mid
;
1050 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1052 sec_info
= elf_section_data (sec
)->sec_info
;
1054 if (offset
>= sec
->rawsize
)
1055 return offset
- sec
->rawsize
+ sec
->size
;
1057 htab
= elf_hash_table (info
);
1058 hdr_info
= &htab
->eh_info
;
1059 if (hdr_info
->offsets_adjusted
)
1060 offset
+= sec
->output_offset
;
1063 hi
= sec_info
->count
;
1067 mid
= (lo
+ hi
) / 2;
1068 if (offset
< sec_info
->entry
[mid
].offset
)
1071 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1077 BFD_ASSERT (lo
< hi
);
1079 /* FDE or CIE was removed. */
1080 if (sec_info
->entry
[mid
].removed
)
1081 return (bfd_vma
) -1;
1083 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1084 relocation against FDE's initial_location field. */
1085 if (!sec_info
->entry
[mid
].cie
1086 && sec_info
->entry
[mid
].cie_inf
->make_relative
1087 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1088 return (bfd_vma
) -2;
1090 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1091 for run-time relocation against LSDA field. */
1092 if (!sec_info
->entry
[mid
].cie
1093 && sec_info
->entry
[mid
].cie_inf
->make_lsda_relative
1094 && (offset
== (sec_info
->entry
[mid
].offset
+ 8
1095 + sec_info
->entry
[mid
].lsda_offset
))
1096 && (sec_info
->entry
[mid
].cie_inf
->need_lsda_relative
1097 || !hdr_info
->offsets_adjusted
))
1099 sec_info
->entry
[mid
].cie_inf
->need_lsda_relative
= 1;
1100 return (bfd_vma
) -2;
1103 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1104 relocation against DW_CFA_set_loc's arguments. */
1105 if (sec_info
->entry
[mid
].set_loc
1106 && (sec_info
->entry
[mid
].cie
1107 ? sec_info
->entry
[mid
].make_relative
1108 : sec_info
->entry
[mid
].cie_inf
->make_relative
)
1109 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1110 + sec_info
->entry
[mid
].set_loc
[1]))
1114 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1115 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1116 + sec_info
->entry
[mid
].set_loc
[cnt
])
1117 return (bfd_vma
) -2;
1120 if (hdr_info
->offsets_adjusted
)
1121 offset
-= sec
->output_offset
;
1122 /* Any new augmentation bytes go before the first relocation. */
1123 return (offset
+ sec_info
->entry
[mid
].new_offset
1124 - sec_info
->entry
[mid
].offset
1125 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1126 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1129 /* Write out .eh_frame section. This is called with the relocated
1133 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1134 struct bfd_link_info
*info
,
1138 struct eh_frame_sec_info
*sec_info
;
1139 struct elf_link_hash_table
*htab
;
1140 struct eh_frame_hdr_info
*hdr_info
;
1141 unsigned int ptr_size
;
1142 struct eh_cie_fde
*ent
;
1144 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1145 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1146 sec
->output_offset
, sec
->size
);
1148 ptr_size
= (get_elf_backend_data (abfd
)
1149 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1150 BFD_ASSERT (ptr_size
!= 0);
1152 sec_info
= elf_section_data (sec
)->sec_info
;
1153 htab
= elf_hash_table (info
);
1154 hdr_info
= &htab
->eh_info
;
1156 /* First convert all offsets to output section offsets, so that a
1157 CIE offset is valid if the CIE is used by a FDE from some other
1158 section. This can happen when duplicate CIEs are deleted in
1159 _bfd_elf_discard_section_eh_frame. We do all sections here because
1160 this function might not be called on sections in the same order as
1161 _bfd_elf_discard_section_eh_frame. */
1162 if (!hdr_info
->offsets_adjusted
)
1166 struct eh_frame_sec_info
*eh_inf
;
1168 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1170 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1171 || (ibfd
->flags
& DYNAMIC
) != 0)
1174 eh
= bfd_get_section_by_name (ibfd
, ".eh_frame");
1175 if (eh
== NULL
|| eh
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1178 eh_inf
= elf_section_data (eh
)->sec_info
;
1179 for (ent
= eh_inf
->entry
; ent
< eh_inf
->entry
+ eh_inf
->count
; ++ent
)
1181 ent
->offset
+= eh
->output_offset
;
1182 ent
->new_offset
+= eh
->output_offset
;
1185 hdr_info
->offsets_adjusted
= TRUE
;
1188 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1190 = bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1191 if (hdr_info
->array
== NULL
)
1194 /* The new offsets can be bigger or smaller than the original offsets.
1195 We therefore need to make two passes over the section: one backward
1196 pass to move entries up and one forward pass to move entries down.
1197 The two passes won't interfere with each other because entries are
1199 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1200 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1201 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1202 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1204 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1205 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1206 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1207 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1209 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1211 unsigned char *buf
, *end
;
1212 unsigned int new_size
;
1219 /* Any terminating FDE must be at the end of the section. */
1220 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1224 buf
= contents
+ ent
->new_offset
- sec
->output_offset
;
1225 end
= buf
+ ent
->size
;
1226 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1228 /* Update the size. It may be shrinked. */
1229 bfd_put_32 (abfd
, new_size
- 4, buf
);
1231 /* Filling the extra bytes with DW_CFA_nops. */
1232 if (new_size
!= ent
->size
)
1233 memset (end
, 0, new_size
- ent
->size
);
1238 if (ent
->make_relative
1239 || ent
->need_lsda_relative
1240 || ent
->per_encoding_relative
)
1243 unsigned int action
, extra_string
, extra_data
;
1244 unsigned int per_width
, per_encoding
;
1246 /* Need to find 'R' or 'L' augmentation's argument and modify
1247 DW_EH_PE_* value. */
1248 action
= ((ent
->make_relative
? 1 : 0)
1249 | (ent
->need_lsda_relative
? 2 : 0)
1250 | (ent
->per_encoding_relative
? 4 : 0));
1251 extra_string
= extra_augmentation_string_bytes (ent
);
1252 extra_data
= extra_augmentation_data_bytes (ent
);
1254 /* Skip length, id and version. */
1257 buf
+= strlen (aug
) + 1;
1258 skip_leb128 (&buf
, end
);
1259 skip_leb128 (&buf
, end
);
1260 skip_leb128 (&buf
, end
);
1263 /* The uleb128 will always be a single byte for the kind
1264 of augmentation strings that we're prepared to handle. */
1265 *buf
++ += extra_data
;
1269 /* Make room for the new augmentation string and data bytes. */
1270 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1271 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1272 buf
+= extra_string
;
1273 end
+= extra_string
+ extra_data
;
1275 if (ent
->add_augmentation_size
)
1278 *buf
++ = extra_data
- 1;
1280 if (ent
->add_fde_encoding
)
1282 BFD_ASSERT (action
& 1);
1284 *buf
++ = DW_EH_PE_pcrel
;
1294 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1295 *buf
|= DW_EH_PE_pcrel
;
1301 per_encoding
= *buf
++;
1302 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1303 BFD_ASSERT (per_width
!= 0);
1304 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1305 == ent
->per_encoding_relative
);
1306 if ((per_encoding
& 0xf0) == DW_EH_PE_aligned
)
1308 + ((buf
- contents
+ per_width
- 1)
1309 & ~((bfd_size_type
) per_width
- 1)));
1314 val
= read_value (abfd
, buf
, per_width
,
1315 get_DW_EH_PE_signed (per_encoding
));
1316 val
+= ent
->offset
- ent
->new_offset
;
1317 val
-= extra_string
+ extra_data
;
1318 write_value (abfd
, buf
, val
, per_width
);
1326 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1327 *buf
|= DW_EH_PE_pcrel
;
1342 bfd_vma value
, address
;
1348 value
= ent
->new_offset
+ 4 - ent
->cie_inf
->new_offset
;
1349 bfd_put_32 (abfd
, value
, buf
);
1351 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1352 value
= read_value (abfd
, buf
, width
,
1353 get_DW_EH_PE_signed (ent
->fde_encoding
));
1357 switch (ent
->fde_encoding
& 0xf0)
1359 case DW_EH_PE_indirect
:
1360 case DW_EH_PE_textrel
:
1361 BFD_ASSERT (hdr_info
== NULL
);
1363 case DW_EH_PE_datarel
:
1365 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1367 BFD_ASSERT (got
!= NULL
);
1368 address
+= got
->vma
;
1371 case DW_EH_PE_pcrel
:
1372 value
+= ent
->offset
- ent
->new_offset
;
1373 address
+= sec
->output_section
->vma
+ ent
->offset
+ 8;
1376 if (ent
->cie_inf
->make_relative
)
1377 value
-= sec
->output_section
->vma
+ ent
->new_offset
+ 8;
1378 write_value (abfd
, buf
, value
, width
);
1385 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1386 hdr_info
->array
[hdr_info
->array_count
++].fde
1387 = sec
->output_section
->vma
+ ent
->new_offset
;
1390 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
1391 || ent
->cie_inf
->need_lsda_relative
)
1393 buf
+= ent
->lsda_offset
;
1394 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1395 value
= read_value (abfd
, buf
, width
,
1396 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1399 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1400 value
+= ent
->offset
- ent
->new_offset
;
1401 else if (ent
->cie_inf
->need_lsda_relative
)
1402 value
-= (sec
->output_section
->vma
+ ent
->new_offset
+ 8
1403 + ent
->lsda_offset
);
1404 write_value (abfd
, buf
, value
, width
);
1407 else if (ent
->cie_inf
->add_augmentation_size
)
1409 /* Skip the PC and length and insert a zero byte for the
1410 augmentation size. */
1412 memmove (buf
+ 1, buf
, end
- buf
);
1418 /* Adjust DW_CFA_set_loc. */
1419 unsigned int cnt
, width
;
1422 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1423 new_offset
= ent
->new_offset
+ 8
1424 + extra_augmentation_string_bytes (ent
)
1425 + extra_augmentation_data_bytes (ent
);
1427 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1430 buf
= start
+ ent
->set_loc
[cnt
];
1432 value
= read_value (abfd
, buf
, width
,
1433 get_DW_EH_PE_signed (ent
->fde_encoding
));
1437 if ((ent
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1438 value
+= ent
->offset
+ 8 - new_offset
;
1439 if (ent
->cie_inf
->make_relative
)
1440 value
-= sec
->output_section
->vma
+ new_offset
1441 + ent
->set_loc
[cnt
];
1442 write_value (abfd
, buf
, value
, width
);
1448 /* We don't align the section to its section alignment since the
1449 runtime library only expects all CIE/FDE records aligned at
1450 the pointer size. _bfd_elf_discard_section_eh_frame should
1451 have padded CIE/FDE records to multiple of pointer size with
1452 size_of_output_cie_fde. */
1453 if ((sec
->size
% ptr_size
) != 0)
1456 return bfd_set_section_contents (abfd
, sec
->output_section
,
1457 contents
, (file_ptr
) sec
->output_offset
,
1461 /* Helper function used to sort .eh_frame_hdr search table by increasing
1462 VMA of FDE initial location. */
1465 vma_compare (const void *a
, const void *b
)
1467 const struct eh_frame_array_ent
*p
= a
;
1468 const struct eh_frame_array_ent
*q
= b
;
1469 if (p
->initial_loc
> q
->initial_loc
)
1471 if (p
->initial_loc
< q
->initial_loc
)
1476 /* Write out .eh_frame_hdr section. This must be called after
1477 _bfd_elf_write_section_eh_frame has been called on all input
1479 .eh_frame_hdr format:
1480 ubyte version (currently 1)
1481 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1483 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1484 number (or DW_EH_PE_omit if there is no
1485 binary search table computed))
1486 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1487 or DW_EH_PE_omit if not present.
1488 DW_EH_PE_datarel is using address of
1489 .eh_frame_hdr section start as base)
1490 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1491 optionally followed by:
1492 [encoded] fde_count (total number of FDEs in .eh_frame section)
1493 fde_count x [encoded] initial_loc, fde
1494 (array of encoded pairs containing
1495 FDE initial_location field and FDE address,
1496 sorted by increasing initial_loc). */
1499 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1501 struct elf_link_hash_table
*htab
;
1502 struct eh_frame_hdr_info
*hdr_info
;
1505 asection
*eh_frame_sec
;
1508 bfd_vma encoded_eh_frame
;
1510 htab
= elf_hash_table (info
);
1511 hdr_info
= &htab
->eh_info
;
1512 sec
= hdr_info
->hdr_sec
;
1516 size
= EH_FRAME_HDR_SIZE
;
1517 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1518 size
+= 4 + hdr_info
->fde_count
* 8;
1519 contents
= bfd_malloc (size
);
1520 if (contents
== NULL
)
1523 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1524 if (eh_frame_sec
== NULL
)
1530 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1531 contents
[0] = 1; /* Version. */
1532 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1533 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1534 &encoded_eh_frame
); /* .eh_frame offset. */
1536 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1538 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1539 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1543 contents
[2] = DW_EH_PE_omit
;
1544 contents
[3] = DW_EH_PE_omit
;
1546 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1548 if (contents
[2] != DW_EH_PE_omit
)
1552 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1553 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1555 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1558 hdr_info
->array
[i
].initial_loc
1559 - sec
->output_section
->vma
,
1560 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1562 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1563 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1567 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1568 contents
, (file_ptr
) sec
->output_offset
,
1574 /* Return the width of FDE addresses. This is the default implementation. */
1577 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1579 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1582 /* Decide whether we can use a PC-relative encoding within the given
1583 EH frame section. This is the default implementation. */
1586 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1587 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1588 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1593 /* Select an encoding for the given address. Preference is given to
1594 PC-relative addressing modes. */
1597 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1598 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1599 asection
*osec
, bfd_vma offset
,
1600 asection
*loc_sec
, bfd_vma loc_offset
,
1603 *encoded
= osec
->vma
+ offset
-
1604 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1605 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;