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 unsigned char local_personality
;
36 char augmentation
[20];
38 bfd_signed_vma data_align
;
40 bfd_vma augmentation_size
;
42 struct elf_link_hash_entry
*h
;
46 struct eh_cie_fde
*cie_inf
;
47 unsigned char per_encoding
;
48 unsigned char lsda_encoding
;
49 unsigned char fde_encoding
;
50 unsigned char initial_insn_length
;
51 unsigned char make_relative
;
52 unsigned char make_lsda_relative
;
53 unsigned char initial_instructions
[50];
58 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
59 move onto the next byte. Return true on success. */
61 static inline bfd_boolean
62 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
66 *result
= *((*iter
)++);
70 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
71 Return true it was possible to move LENGTH bytes. */
73 static inline bfd_boolean
74 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
76 if ((bfd_size_type
) (end
- *iter
) < length
)
85 /* Move *ITER over an leb128, stopping at END. Return true if the end
86 of the leb128 was found. */
89 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
93 if (!read_byte (iter
, end
, &byte
))
99 /* Like skip_leb128, but treat the leb128 as an unsigned value and
100 store it in *VALUE. */
103 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
108 if (!skip_leb128 (iter
, end
))
114 *value
= (*value
<< 7) | (*--p
& 0x7f);
119 /* Like read_uleb128, but for signed values. */
122 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
127 if (!skip_leb128 (iter
, end
))
131 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
133 *value
= (*value
<< 7) | (*--p
& 0x7f);
138 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
141 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
143 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
145 if ((encoding
& 0x60) == 0x60)
148 switch (encoding
& 7)
150 case DW_EH_PE_udata2
: return 2;
151 case DW_EH_PE_udata4
: return 4;
152 case DW_EH_PE_udata8
: return 8;
153 case DW_EH_PE_absptr
: return ptr_size
;
161 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
163 /* Read a width sized value from memory. */
166 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
174 value
= bfd_get_signed_16 (abfd
, buf
);
176 value
= bfd_get_16 (abfd
, buf
);
180 value
= bfd_get_signed_32 (abfd
, buf
);
182 value
= bfd_get_32 (abfd
, buf
);
186 value
= bfd_get_signed_64 (abfd
, buf
);
188 value
= bfd_get_64 (abfd
, buf
);
198 /* Store a width sized value to memory. */
201 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
205 case 2: bfd_put_16 (abfd
, value
, buf
); break;
206 case 4: bfd_put_32 (abfd
, value
, buf
); break;
207 case 8: bfd_put_64 (abfd
, value
, buf
); break;
208 default: BFD_FAIL ();
212 /* Return one if C1 and C2 CIEs can be merged. */
215 cie_eq (const void *e1
, const void *e2
)
217 const struct cie
*c1
= e1
;
218 const struct cie
*c2
= e2
;
220 if (c1
->hash
== c2
->hash
221 && c1
->length
== c2
->length
222 && c1
->version
== c2
->version
223 && c1
->local_personality
== c2
->local_personality
224 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
225 && strcmp (c1
->augmentation
, "eh") != 0
226 && c1
->code_align
== c2
->code_align
227 && c1
->data_align
== c2
->data_align
228 && c1
->ra_column
== c2
->ra_column
229 && c1
->augmentation_size
== c2
->augmentation_size
230 && memcmp (&c1
->personality
, &c2
->personality
,
231 sizeof (c1
->personality
)) == 0
232 && c1
->output_sec
== c2
->output_sec
233 && c1
->per_encoding
== c2
->per_encoding
234 && c1
->lsda_encoding
== c2
->lsda_encoding
235 && c1
->fde_encoding
== c2
->fde_encoding
236 && c1
->initial_insn_length
== c2
->initial_insn_length
237 && memcmp (c1
->initial_instructions
,
238 c2
->initial_instructions
,
239 c1
->initial_insn_length
) == 0)
246 cie_hash (const void *e
)
248 const struct cie
*c
= e
;
253 cie_compute_hash (struct cie
*c
)
256 h
= iterative_hash_object (c
->length
, h
);
257 h
= iterative_hash_object (c
->version
, h
);
258 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
259 h
= iterative_hash_object (c
->code_align
, h
);
260 h
= iterative_hash_object (c
->data_align
, h
);
261 h
= iterative_hash_object (c
->ra_column
, h
);
262 h
= iterative_hash_object (c
->augmentation_size
, h
);
263 h
= iterative_hash_object (c
->personality
, h
);
264 h
= iterative_hash_object (c
->output_sec
, h
);
265 h
= iterative_hash_object (c
->per_encoding
, h
);
266 h
= iterative_hash_object (c
->lsda_encoding
, h
);
267 h
= iterative_hash_object (c
->fde_encoding
, h
);
268 h
= iterative_hash_object (c
->initial_insn_length
, h
);
269 h
= iterative_hash (c
->initial_instructions
, c
->initial_insn_length
, h
);
274 /* Return the number of extra bytes that we'll be inserting into
275 ENTRY's augmentation string. */
277 static INLINE
unsigned int
278 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
280 unsigned int size
= 0;
283 if (entry
->add_augmentation_size
)
285 if (entry
->add_fde_encoding
)
291 /* Likewise ENTRY's augmentation data. */
293 static INLINE
unsigned int
294 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
296 unsigned int size
= 0;
299 if (entry
->add_augmentation_size
)
301 if (entry
->add_fde_encoding
)
306 if (entry
->cie_inf
->add_augmentation_size
)
312 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
313 required alignment of ENTRY in bytes. */
316 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
320 if (entry
->size
== 4)
323 + extra_augmentation_string_bytes (entry
)
324 + extra_augmentation_data_bytes (entry
)
325 + alignment
- 1) & -alignment
;
328 /* Assume that the bytes between *ITER and END are CFA instructions.
329 Try to move *ITER past the first instruction and return true on
330 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
333 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
338 if (!read_byte (iter
, end
, &op
))
341 switch (op
& 0xc0 ? op
& 0xc0 : op
)
344 case DW_CFA_advance_loc
:
346 case DW_CFA_remember_state
:
347 case DW_CFA_restore_state
:
348 case DW_CFA_GNU_window_save
:
353 case DW_CFA_restore_extended
:
354 case DW_CFA_undefined
:
355 case DW_CFA_same_value
:
356 case DW_CFA_def_cfa_register
:
357 case DW_CFA_def_cfa_offset
:
358 case DW_CFA_def_cfa_offset_sf
:
359 case DW_CFA_GNU_args_size
:
360 /* One leb128 argument. */
361 return skip_leb128 (iter
, end
);
363 case DW_CFA_val_offset
:
364 case DW_CFA_val_offset_sf
:
365 case DW_CFA_offset_extended
:
366 case DW_CFA_register
:
368 case DW_CFA_offset_extended_sf
:
369 case DW_CFA_GNU_negative_offset_extended
:
370 case DW_CFA_def_cfa_sf
:
371 /* Two leb128 arguments. */
372 return (skip_leb128 (iter
, end
)
373 && skip_leb128 (iter
, end
));
375 case DW_CFA_def_cfa_expression
:
376 /* A variable-length argument. */
377 return (read_uleb128 (iter
, end
, &length
)
378 && skip_bytes (iter
, end
, length
));
380 case DW_CFA_expression
:
381 case DW_CFA_val_expression
:
382 /* A leb128 followed by a variable-length argument. */
383 return (skip_leb128 (iter
, end
)
384 && read_uleb128 (iter
, end
, &length
)
385 && skip_bytes (iter
, end
, length
));
388 return skip_bytes (iter
, end
, encoded_ptr_width
);
390 case DW_CFA_advance_loc1
:
391 return skip_bytes (iter
, end
, 1);
393 case DW_CFA_advance_loc2
:
394 return skip_bytes (iter
, end
, 2);
396 case DW_CFA_advance_loc4
:
397 return skip_bytes (iter
, end
, 4);
399 case DW_CFA_MIPS_advance_loc8
:
400 return skip_bytes (iter
, end
, 8);
407 /* Try to interpret the bytes between BUF and END as CFA instructions.
408 If every byte makes sense, return a pointer to the first DW_CFA_nop
409 padding byte, or END if there is no padding. Return null otherwise.
410 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
413 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
414 unsigned int *set_loc_count
)
420 if (*buf
== DW_CFA_nop
)
424 if (*buf
== DW_CFA_set_loc
)
426 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
433 /* This function is called for each input file before the .eh_frame
434 section is relocated. It discards duplicate CIEs and FDEs for discarded
435 functions. The function returns TRUE iff any entries have been
439 _bfd_elf_discard_section_eh_frame
440 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
441 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
442 struct elf_reloc_cookie
*cookie
)
444 #define REQUIRE(COND) \
447 goto free_no_table; \
450 bfd_byte
*ehbuf
= NULL
, *buf
;
452 struct eh_cie_fde
*ent
, *this_inf
;
453 unsigned int hdr_length
, hdr_id
;
458 unsigned int usage_count
;
460 } *ecies
= NULL
, *ecie
;
461 unsigned int ecie_count
= 0, ecie_alloced
= 0;
463 struct elf_link_hash_table
*htab
;
464 struct eh_frame_hdr_info
*hdr_info
;
465 struct eh_frame_sec_info
*sec_info
= NULL
;
467 unsigned int ptr_size
;
468 unsigned int entry_alloced
;
472 /* This file does not contain .eh_frame information. */
476 if (bfd_is_abs_section (sec
->output_section
))
478 /* At least one of the sections is being discarded from the
479 link, so we should just ignore them. */
483 htab
= elf_hash_table (info
);
484 hdr_info
= &htab
->eh_info
;
486 if (hdr_info
->cies
== NULL
&& !info
->relocatable
)
487 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
489 /* Read the frame unwind information from abfd. */
491 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
494 && bfd_get_32 (abfd
, ehbuf
) == 0
495 && cookie
->rel
== cookie
->relend
)
497 /* Empty .eh_frame section. */
502 /* If .eh_frame section size doesn't fit into int, we cannot handle
503 it (it would need to use 64-bit .eh_frame format anyway). */
504 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
506 ptr_size
= (get_elf_backend_data (abfd
)
507 ->elf_backend_eh_frame_address_size (abfd
, sec
));
508 REQUIRE (ptr_size
!= 0);
511 sec_info
= bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
512 + 99 * sizeof (struct eh_cie_fde
));
517 #define ENSURE_NO_RELOCS(buf) \
518 REQUIRE (!(cookie->rel < cookie->relend \
519 && (cookie->rel->r_offset \
520 < (bfd_size_type) ((buf) - ehbuf)) \
521 && cookie->rel->r_info != 0))
523 #define SKIP_RELOCS(buf) \
524 while (cookie->rel < cookie->relend \
525 && (cookie->rel->r_offset \
526 < (bfd_size_type) ((buf) - ehbuf))) \
529 #define GET_RELOC(buf) \
530 ((cookie->rel < cookie->relend \
531 && (cookie->rel->r_offset \
532 == (bfd_size_type) ((buf) - ehbuf))) \
533 ? cookie->rel : NULL)
538 bfd_byte
*start
, *end
, *insns
, *insns_end
;
539 bfd_size_type length
;
540 unsigned int set_loc_count
;
542 if (sec_info
->count
== entry_alloced
)
544 sec_info
= bfd_realloc (sec_info
,
545 sizeof (struct eh_frame_sec_info
)
546 + ((entry_alloced
+ 99)
547 * sizeof (struct eh_cie_fde
)));
550 memset (&sec_info
->entry
[entry_alloced
], 0,
551 100 * sizeof (struct eh_cie_fde
));
552 entry_alloced
+= 100;
555 this_inf
= sec_info
->entry
+ sec_info
->count
;
558 if ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
)
561 /* Read the length of the entry. */
562 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
563 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
565 /* 64-bit .eh_frame is not supported. */
566 REQUIRE (hdr_length
!= 0xffffffff);
568 /* The CIE/FDE must be fully contained in this input section. */
569 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
570 end
= buf
+ hdr_length
;
572 this_inf
->offset
= last_fde
- ehbuf
;
573 this_inf
->size
= 4 + hdr_length
;
577 /* A zero-length CIE should only be found at the end of
579 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
580 ENSURE_NO_RELOCS (buf
);
585 REQUIRE (skip_bytes (&buf
, end
, 4));
586 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
590 unsigned int initial_insn_length
;
595 if (ecie_count
== ecie_alloced
)
597 ecies
= bfd_realloc (ecies
,
598 (ecie_alloced
+ 20) * sizeof (*ecies
));
600 memset (&ecies
[ecie_alloced
], 0, 20 * sizeof (*ecies
));
604 cie
= &ecies
[ecie_count
].cie
;
605 ecies
[ecie_count
].offset
= this_inf
->offset
;
606 ecies
[ecie_count
++].entry
= sec_info
->count
;
607 cie
->length
= hdr_length
;
609 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
611 /* Cannot handle unknown versions. */
612 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
613 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
615 strcpy (cie
->augmentation
, (char *) buf
);
616 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
617 ENSURE_NO_RELOCS (buf
);
618 if (buf
[0] == 'e' && buf
[1] == 'h')
620 /* GCC < 3.0 .eh_frame CIE */
621 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
622 is private to each CIE, so we don't need it for anything.
624 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
627 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
628 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
629 if (cie
->version
== 1)
632 cie
->ra_column
= *buf
++;
635 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
636 ENSURE_NO_RELOCS (buf
);
637 cie
->lsda_encoding
= DW_EH_PE_omit
;
638 cie
->fde_encoding
= DW_EH_PE_omit
;
639 cie
->per_encoding
= DW_EH_PE_omit
;
640 aug
= cie
->augmentation
;
641 if (aug
[0] != 'e' || aug
[1] != 'h')
646 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
647 ENSURE_NO_RELOCS (buf
);
654 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
655 ENSURE_NO_RELOCS (buf
);
656 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
659 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
660 ENSURE_NO_RELOCS (buf
);
661 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
669 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
670 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
673 if ((cie
->per_encoding
& 0xf0) == DW_EH_PE_aligned
)
675 length
= -(buf
- ehbuf
) & (per_width
- 1);
676 REQUIRE (skip_bytes (&buf
, end
, length
));
678 ENSURE_NO_RELOCS (buf
);
679 /* Ensure we have a reloc here. */
680 if (GET_RELOC (buf
) != NULL
)
682 unsigned long r_symndx
;
686 r_symndx
= ELF64_R_SYM (cookie
->rel
->r_info
);
689 r_symndx
= ELF32_R_SYM (cookie
->rel
->r_info
);
690 if (r_symndx
>= cookie
->locsymcount
691 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
]
692 .st_info
) != STB_LOCAL
)
694 struct elf_link_hash_entry
*h
;
696 r_symndx
-= cookie
->extsymoff
;
697 h
= cookie
->sym_hashes
[r_symndx
];
699 while (h
->root
.type
== bfd_link_hash_indirect
700 || h
->root
.type
== bfd_link_hash_warning
)
701 h
= (struct elf_link_hash_entry
*)
704 cie
->personality
.h
= h
;
708 Elf_Internal_Sym
*sym
;
712 sym
= &cookie
->locsyms
[r_symndx
];
713 sym_sec
= (bfd_section_from_elf_index
714 (abfd
, sym
->st_shndx
));
715 if (sym_sec
->kept_section
!= NULL
)
716 sym_sec
= sym_sec
->kept_section
;
718 && sym_sec
->output_section
!= NULL
)
721 + sym_sec
->output_offset
722 + sym_sec
->output_section
->vma
);
723 cie
->personality
.val
= val
;
724 cie
->local_personality
= 1;
728 /* Cope with MIPS-style composite relocations. */
731 while (GET_RELOC (buf
) != NULL
);
733 REQUIRE (skip_bytes (&buf
, end
, per_width
));
734 REQUIRE (cie
->local_personality
|| cie
->personality
.h
);
738 /* Unrecognized augmentation. Better bail out. */
743 /* For shared libraries, try to get rid of as many RELATIVE relocs
746 && (get_elf_backend_data (abfd
)
747 ->elf_backend_can_make_relative_eh_frame
750 if ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
)
751 cie
->make_relative
= 1;
752 /* If the CIE doesn't already have an 'R' entry, it's fairly
753 easy to add one, provided that there's no aligned data
754 after the augmentation string. */
755 else if (cie
->fde_encoding
== DW_EH_PE_omit
756 && (cie
->per_encoding
& 0xf0) != DW_EH_PE_aligned
)
758 if (*cie
->augmentation
== 0)
759 this_inf
->add_augmentation_size
= 1;
760 this_inf
->add_fde_encoding
= 1;
761 cie
->make_relative
= 1;
766 && (get_elf_backend_data (abfd
)
767 ->elf_backend_can_make_lsda_relative_eh_frame
769 && (cie
->lsda_encoding
& 0xf0) == DW_EH_PE_absptr
)
770 cie
->make_lsda_relative
= 1;
772 /* If FDE encoding was not specified, it defaults to
774 if (cie
->fde_encoding
== DW_EH_PE_omit
)
775 cie
->fde_encoding
= DW_EH_PE_absptr
;
777 initial_insn_length
= end
- buf
;
778 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
780 cie
->initial_insn_length
= initial_insn_length
;
781 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
784 buf
+= initial_insn_length
;
785 ENSURE_NO_RELOCS (buf
);
789 /* Find the corresponding CIE. */
790 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
791 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
792 if (cie_offset
== ecie
->offset
)
795 /* Ensure this FDE references one of the CIEs in this input
797 REQUIRE (ecie
!= ecies
+ ecie_count
);
800 ENSURE_NO_RELOCS (buf
);
801 REQUIRE (GET_RELOC (buf
));
803 if ((*reloc_symbol_deleted_p
) (buf
- ehbuf
, cookie
))
804 /* This is a FDE against a discarded section. It should
806 this_inf
->removed
= 1;
810 && (((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
811 && cie
->make_relative
== 0)
812 || (cie
->fde_encoding
& 0xf0) == DW_EH_PE_aligned
))
814 /* If a shared library uses absolute pointers
815 which we cannot turn into PC relative,
816 don't create the binary search table,
817 since it is affected by runtime relocations. */
818 hdr_info
->table
= FALSE
;
819 (*info
->callbacks
->einfo
)
820 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
821 " table being created.\n"), abfd
, sec
);
824 hdr_info
->fde_count
++;
825 this_inf
->cie_inf
= (void *) (ecie
- ecies
);
828 /* Skip the initial location and address range. */
830 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
831 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
833 /* Skip the augmentation size, if present. */
834 if (cie
->augmentation
[0] == 'z')
835 REQUIRE (read_uleb128 (&buf
, end
, &length
));
839 /* Of the supported augmentation characters above, only 'L'
840 adds augmentation data to the FDE. This code would need to
841 be adjusted if any future augmentations do the same thing. */
842 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
844 this_inf
->lsda_offset
= buf
- start
;
845 /* If there's no 'z' augmentation, we don't know where the
846 CFA insns begin. Assume no padding. */
847 if (cie
->augmentation
[0] != 'z')
851 /* Skip over the augmentation data. */
852 REQUIRE (skip_bytes (&buf
, end
, length
));
855 buf
= last_fde
+ 4 + hdr_length
;
859 /* Try to interpret the CFA instructions and find the first
860 padding nop. Shrink this_inf's size so that it doesn't
861 include the padding. */
862 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
864 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
865 /* If we don't understand the CFA instructions, we can't know
866 what needs to be adjusted there. */
867 if (insns_end
== NULL
868 /* For the time being we don't support DW_CFA_set_loc in
870 || (set_loc_count
&& this_inf
->cie
))
872 this_inf
->size
-= end
- insns_end
;
873 if (insns_end
!= end
&& this_inf
->cie
)
875 cie
->initial_insn_length
-= end
- insns_end
;
876 cie
->length
-= end
- insns_end
;
879 && ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
880 || cie
->make_relative
))
885 this_inf
->set_loc
= bfd_malloc ((set_loc_count
+ 1)
886 * sizeof (unsigned int));
887 REQUIRE (this_inf
->set_loc
);
888 this_inf
->set_loc
[0] = set_loc_count
;
893 if (*p
== DW_CFA_set_loc
)
894 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
895 REQUIRE (skip_cfa_op (&p
, end
, length
));
899 this_inf
->fde_encoding
= cie
->fde_encoding
;
900 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
904 elf_section_data (sec
)->sec_info
= sec_info
;
905 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
907 /* Look at all CIEs in this section and determine which can be
908 removed as unused, which can be merged with previous duplicate
909 CIEs and which need to be kept. */
910 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
912 if (ecie
->usage_count
== 0)
914 sec_info
->entry
[ecie
->entry
].removed
= 1;
917 ecie
->cie
.output_sec
= sec
->output_section
;
918 ecie
->cie
.cie_inf
= sec_info
->entry
+ ecie
->entry
;
919 cie_compute_hash (&ecie
->cie
);
920 if (hdr_info
->cies
!= NULL
)
922 void **loc
= htab_find_slot_with_hash (hdr_info
->cies
, &ecie
->cie
,
923 ecie
->cie
.hash
, INSERT
);
926 if (*loc
!= HTAB_EMPTY_ENTRY
)
928 sec_info
->entry
[ecie
->entry
].removed
= 1;
929 ecie
->cie
.cie_inf
= ((struct cie
*) *loc
)->cie_inf
;
933 *loc
= malloc (sizeof (struct cie
));
935 *loc
= HTAB_DELETED_ENTRY
;
937 memcpy (*loc
, &ecie
->cie
, sizeof (struct cie
));
940 ecie
->cie
.cie_inf
->make_relative
= ecie
->cie
.make_relative
;
941 ecie
->cie
.cie_inf
->make_lsda_relative
= ecie
->cie
.make_lsda_relative
;
942 ecie
->cie
.cie_inf
->per_encoding_relative
943 = (ecie
->cie
.per_encoding
& 0x70) == DW_EH_PE_pcrel
;
946 /* Ok, now we can assign new offsets. */
948 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
953 ecie
= ecies
+ (unsigned long) ent
->cie_inf
;
954 ent
->cie_inf
= ecie
->cie
.cie_inf
;
956 ent
->new_offset
= offset
;
957 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
960 /* Resize the sec as needed. */
961 sec
->rawsize
= sec
->size
;
967 return offset
!= sec
->rawsize
;
970 (*info
->callbacks
->einfo
)
971 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
979 hdr_info
->table
= FALSE
;
985 /* This function is called for .eh_frame_hdr section after
986 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
987 input sections. It finalizes the size of .eh_frame_hdr section. */
990 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
992 struct elf_link_hash_table
*htab
;
993 struct eh_frame_hdr_info
*hdr_info
;
996 htab
= elf_hash_table (info
);
997 hdr_info
= &htab
->eh_info
;
999 if (hdr_info
->cies
!= NULL
)
1001 htab_delete (hdr_info
->cies
);
1002 hdr_info
->cies
= NULL
;
1005 sec
= hdr_info
->hdr_sec
;
1009 sec
->size
= EH_FRAME_HDR_SIZE
;
1010 if (hdr_info
->table
)
1011 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1013 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1017 /* This function is called from size_dynamic_sections.
1018 It needs to decide whether .eh_frame_hdr should be output or not,
1019 because when the dynamic symbol table has been sized it is too late
1020 to strip sections. */
1023 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1027 struct elf_link_hash_table
*htab
;
1028 struct eh_frame_hdr_info
*hdr_info
;
1030 htab
= elf_hash_table (info
);
1031 hdr_info
= &htab
->eh_info
;
1032 if (hdr_info
->hdr_sec
== NULL
)
1035 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1037 hdr_info
->hdr_sec
= NULL
;
1042 if (info
->eh_frame_hdr
)
1043 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1045 /* Count only sections which have at least a single CIE or FDE.
1046 There cannot be any CIE or FDE <= 8 bytes. */
1047 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1048 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1054 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1055 hdr_info
->hdr_sec
= NULL
;
1059 hdr_info
->table
= TRUE
;
1063 /* Adjust an address in the .eh_frame section. Given OFFSET within
1064 SEC, this returns the new offset in the adjusted .eh_frame section,
1065 or -1 if the address refers to a CIE/FDE which has been removed
1066 or to offset with dynamic relocation which is no longer needed. */
1069 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1070 struct bfd_link_info
*info
,
1074 struct eh_frame_sec_info
*sec_info
;
1075 struct elf_link_hash_table
*htab
;
1076 struct eh_frame_hdr_info
*hdr_info
;
1077 unsigned int lo
, hi
, mid
;
1079 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1081 sec_info
= elf_section_data (sec
)->sec_info
;
1083 if (offset
>= sec
->rawsize
)
1084 return offset
- sec
->rawsize
+ sec
->size
;
1086 htab
= elf_hash_table (info
);
1087 hdr_info
= &htab
->eh_info
;
1088 if (hdr_info
->offsets_adjusted
)
1089 offset
+= sec
->output_offset
;
1092 hi
= sec_info
->count
;
1096 mid
= (lo
+ hi
) / 2;
1097 if (offset
< sec_info
->entry
[mid
].offset
)
1100 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1106 BFD_ASSERT (lo
< hi
);
1108 /* FDE or CIE was removed. */
1109 if (sec_info
->entry
[mid
].removed
)
1110 return (bfd_vma
) -1;
1112 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1113 relocation against FDE's initial_location field. */
1114 if (!sec_info
->entry
[mid
].cie
1115 && sec_info
->entry
[mid
].cie_inf
->make_relative
1116 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1117 return (bfd_vma
) -2;
1119 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1120 for run-time relocation against LSDA field. */
1121 if (!sec_info
->entry
[mid
].cie
1122 && sec_info
->entry
[mid
].cie_inf
->make_lsda_relative
1123 && (offset
== (sec_info
->entry
[mid
].offset
+ 8
1124 + sec_info
->entry
[mid
].lsda_offset
))
1125 && (sec_info
->entry
[mid
].cie_inf
->need_lsda_relative
1126 || !hdr_info
->offsets_adjusted
))
1128 sec_info
->entry
[mid
].cie_inf
->need_lsda_relative
= 1;
1129 return (bfd_vma
) -2;
1132 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1133 relocation against DW_CFA_set_loc's arguments. */
1134 if (sec_info
->entry
[mid
].set_loc
1135 && (sec_info
->entry
[mid
].cie
1136 ? sec_info
->entry
[mid
].make_relative
1137 : sec_info
->entry
[mid
].cie_inf
->make_relative
)
1138 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1139 + sec_info
->entry
[mid
].set_loc
[1]))
1143 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1144 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1145 + sec_info
->entry
[mid
].set_loc
[cnt
])
1146 return (bfd_vma
) -2;
1149 if (hdr_info
->offsets_adjusted
)
1150 offset
-= sec
->output_offset
;
1151 /* Any new augmentation bytes go before the first relocation. */
1152 return (offset
+ sec_info
->entry
[mid
].new_offset
1153 - sec_info
->entry
[mid
].offset
1154 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1155 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1158 /* Write out .eh_frame section. This is called with the relocated
1162 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1163 struct bfd_link_info
*info
,
1167 struct eh_frame_sec_info
*sec_info
;
1168 struct elf_link_hash_table
*htab
;
1169 struct eh_frame_hdr_info
*hdr_info
;
1170 unsigned int ptr_size
;
1171 struct eh_cie_fde
*ent
;
1173 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1174 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1175 sec
->output_offset
, sec
->size
);
1177 ptr_size
= (get_elf_backend_data (abfd
)
1178 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1179 BFD_ASSERT (ptr_size
!= 0);
1181 sec_info
= elf_section_data (sec
)->sec_info
;
1182 htab
= elf_hash_table (info
);
1183 hdr_info
= &htab
->eh_info
;
1185 /* First convert all offsets to output section offsets, so that a
1186 CIE offset is valid if the CIE is used by a FDE from some other
1187 section. This can happen when duplicate CIEs are deleted in
1188 _bfd_elf_discard_section_eh_frame. We do all sections here because
1189 this function might not be called on sections in the same order as
1190 _bfd_elf_discard_section_eh_frame. */
1191 if (!hdr_info
->offsets_adjusted
)
1195 struct eh_frame_sec_info
*eh_inf
;
1197 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1199 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1200 || (ibfd
->flags
& DYNAMIC
) != 0)
1203 eh
= bfd_get_section_by_name (ibfd
, ".eh_frame");
1204 if (eh
== NULL
|| eh
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1207 eh_inf
= elf_section_data (eh
)->sec_info
;
1208 for (ent
= eh_inf
->entry
; ent
< eh_inf
->entry
+ eh_inf
->count
; ++ent
)
1210 ent
->offset
+= eh
->output_offset
;
1211 ent
->new_offset
+= eh
->output_offset
;
1214 hdr_info
->offsets_adjusted
= TRUE
;
1217 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1219 = bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1220 if (hdr_info
->array
== NULL
)
1223 /* The new offsets can be bigger or smaller than the original offsets.
1224 We therefore need to make two passes over the section: one backward
1225 pass to move entries up and one forward pass to move entries down.
1226 The two passes won't interfere with each other because entries are
1228 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1229 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1230 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1231 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1233 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1234 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1235 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1236 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1238 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1240 unsigned char *buf
, *end
;
1241 unsigned int new_size
;
1248 /* Any terminating FDE must be at the end of the section. */
1249 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1253 buf
= contents
+ ent
->new_offset
- sec
->output_offset
;
1254 end
= buf
+ ent
->size
;
1255 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1257 /* Update the size. It may be shrinked. */
1258 bfd_put_32 (abfd
, new_size
- 4, buf
);
1260 /* Filling the extra bytes with DW_CFA_nops. */
1261 if (new_size
!= ent
->size
)
1262 memset (end
, 0, new_size
- ent
->size
);
1267 if (ent
->make_relative
1268 || ent
->need_lsda_relative
1269 || ent
->per_encoding_relative
)
1272 unsigned int action
, extra_string
, extra_data
;
1273 unsigned int per_width
, per_encoding
;
1275 /* Need to find 'R' or 'L' augmentation's argument and modify
1276 DW_EH_PE_* value. */
1277 action
= ((ent
->make_relative
? 1 : 0)
1278 | (ent
->need_lsda_relative
? 2 : 0)
1279 | (ent
->per_encoding_relative
? 4 : 0));
1280 extra_string
= extra_augmentation_string_bytes (ent
);
1281 extra_data
= extra_augmentation_data_bytes (ent
);
1283 /* Skip length, id and version. */
1286 buf
+= strlen (aug
) + 1;
1287 skip_leb128 (&buf
, end
);
1288 skip_leb128 (&buf
, end
);
1289 skip_leb128 (&buf
, end
);
1292 /* The uleb128 will always be a single byte for the kind
1293 of augmentation strings that we're prepared to handle. */
1294 *buf
++ += extra_data
;
1298 /* Make room for the new augmentation string and data bytes. */
1299 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1300 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1301 buf
+= extra_string
;
1302 end
+= extra_string
+ extra_data
;
1304 if (ent
->add_augmentation_size
)
1307 *buf
++ = extra_data
- 1;
1309 if (ent
->add_fde_encoding
)
1311 BFD_ASSERT (action
& 1);
1313 *buf
++ = DW_EH_PE_pcrel
;
1323 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1324 *buf
|= DW_EH_PE_pcrel
;
1330 per_encoding
= *buf
++;
1331 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1332 BFD_ASSERT (per_width
!= 0);
1333 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1334 == ent
->per_encoding_relative
);
1335 if ((per_encoding
& 0xf0) == DW_EH_PE_aligned
)
1337 + ((buf
- contents
+ per_width
- 1)
1338 & ~((bfd_size_type
) per_width
- 1)));
1343 val
= read_value (abfd
, buf
, per_width
,
1344 get_DW_EH_PE_signed (per_encoding
));
1345 val
+= ent
->offset
- ent
->new_offset
;
1346 val
-= extra_string
+ extra_data
;
1347 write_value (abfd
, buf
, val
, per_width
);
1355 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1356 *buf
|= DW_EH_PE_pcrel
;
1371 bfd_vma value
, address
;
1377 value
= ent
->new_offset
+ 4 - ent
->cie_inf
->new_offset
;
1378 bfd_put_32 (abfd
, value
, buf
);
1380 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1381 value
= read_value (abfd
, buf
, width
,
1382 get_DW_EH_PE_signed (ent
->fde_encoding
));
1386 switch (ent
->fde_encoding
& 0xf0)
1388 case DW_EH_PE_indirect
:
1389 case DW_EH_PE_textrel
:
1390 BFD_ASSERT (hdr_info
== NULL
);
1392 case DW_EH_PE_datarel
:
1394 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1396 BFD_ASSERT (got
!= NULL
);
1397 address
+= got
->vma
;
1400 case DW_EH_PE_pcrel
:
1401 value
+= ent
->offset
- ent
->new_offset
;
1402 address
+= sec
->output_section
->vma
+ ent
->offset
+ 8;
1405 if (ent
->cie_inf
->make_relative
)
1406 value
-= sec
->output_section
->vma
+ ent
->new_offset
+ 8;
1407 write_value (abfd
, buf
, value
, width
);
1414 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1415 hdr_info
->array
[hdr_info
->array_count
++].fde
1416 = sec
->output_section
->vma
+ ent
->new_offset
;
1419 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
1420 || ent
->cie_inf
->need_lsda_relative
)
1422 buf
+= ent
->lsda_offset
;
1423 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1424 value
= read_value (abfd
, buf
, width
,
1425 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1428 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1429 value
+= ent
->offset
- ent
->new_offset
;
1430 else if (ent
->cie_inf
->need_lsda_relative
)
1431 value
-= (sec
->output_section
->vma
+ ent
->new_offset
+ 8
1432 + ent
->lsda_offset
);
1433 write_value (abfd
, buf
, value
, width
);
1436 else if (ent
->cie_inf
->add_augmentation_size
)
1438 /* Skip the PC and length and insert a zero byte for the
1439 augmentation size. */
1441 memmove (buf
+ 1, buf
, end
- buf
);
1447 /* Adjust DW_CFA_set_loc. */
1448 unsigned int cnt
, width
;
1451 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1452 new_offset
= ent
->new_offset
+ 8
1453 + extra_augmentation_string_bytes (ent
)
1454 + extra_augmentation_data_bytes (ent
);
1456 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1459 buf
= start
+ ent
->set_loc
[cnt
];
1461 value
= read_value (abfd
, buf
, width
,
1462 get_DW_EH_PE_signed (ent
->fde_encoding
));
1466 if ((ent
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1467 value
+= ent
->offset
+ 8 - new_offset
;
1468 if (ent
->cie_inf
->make_relative
)
1469 value
-= sec
->output_section
->vma
+ new_offset
1470 + ent
->set_loc
[cnt
];
1471 write_value (abfd
, buf
, value
, width
);
1477 /* We don't align the section to its section alignment since the
1478 runtime library only expects all CIE/FDE records aligned at
1479 the pointer size. _bfd_elf_discard_section_eh_frame should
1480 have padded CIE/FDE records to multiple of pointer size with
1481 size_of_output_cie_fde. */
1482 if ((sec
->size
% ptr_size
) != 0)
1485 return bfd_set_section_contents (abfd
, sec
->output_section
,
1486 contents
, (file_ptr
) sec
->output_offset
,
1490 /* Helper function used to sort .eh_frame_hdr search table by increasing
1491 VMA of FDE initial location. */
1494 vma_compare (const void *a
, const void *b
)
1496 const struct eh_frame_array_ent
*p
= a
;
1497 const struct eh_frame_array_ent
*q
= b
;
1498 if (p
->initial_loc
> q
->initial_loc
)
1500 if (p
->initial_loc
< q
->initial_loc
)
1505 /* Write out .eh_frame_hdr section. This must be called after
1506 _bfd_elf_write_section_eh_frame has been called on all input
1508 .eh_frame_hdr format:
1509 ubyte version (currently 1)
1510 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1512 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1513 number (or DW_EH_PE_omit if there is no
1514 binary search table computed))
1515 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1516 or DW_EH_PE_omit if not present.
1517 DW_EH_PE_datarel is using address of
1518 .eh_frame_hdr section start as base)
1519 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1520 optionally followed by:
1521 [encoded] fde_count (total number of FDEs in .eh_frame section)
1522 fde_count x [encoded] initial_loc, fde
1523 (array of encoded pairs containing
1524 FDE initial_location field and FDE address,
1525 sorted by increasing initial_loc). */
1528 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1530 struct elf_link_hash_table
*htab
;
1531 struct eh_frame_hdr_info
*hdr_info
;
1534 asection
*eh_frame_sec
;
1537 bfd_vma encoded_eh_frame
;
1539 htab
= elf_hash_table (info
);
1540 hdr_info
= &htab
->eh_info
;
1541 sec
= hdr_info
->hdr_sec
;
1545 size
= EH_FRAME_HDR_SIZE
;
1546 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1547 size
+= 4 + hdr_info
->fde_count
* 8;
1548 contents
= bfd_malloc (size
);
1549 if (contents
== NULL
)
1552 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1553 if (eh_frame_sec
== NULL
)
1559 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1560 contents
[0] = 1; /* Version. */
1561 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1562 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1563 &encoded_eh_frame
); /* .eh_frame offset. */
1565 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1567 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1568 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1572 contents
[2] = DW_EH_PE_omit
;
1573 contents
[3] = DW_EH_PE_omit
;
1575 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1577 if (contents
[2] != DW_EH_PE_omit
)
1581 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1582 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1584 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1587 hdr_info
->array
[i
].initial_loc
1588 - sec
->output_section
->vma
,
1589 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1591 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1592 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1596 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1597 contents
, (file_ptr
) sec
->output_offset
,
1603 /* Return the width of FDE addresses. This is the default implementation. */
1606 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1608 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1611 /* Decide whether we can use a PC-relative encoding within the given
1612 EH frame section. This is the default implementation. */
1615 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1616 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1617 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1622 /* Select an encoding for the given address. Preference is given to
1623 PC-relative addressing modes. */
1626 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1627 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1628 asection
*osec
, bfd_vma offset
,
1629 asection
*loc_sec
, bfd_vma loc_offset
,
1632 *encoded
= osec
->vma
+ offset
-
1633 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1634 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;