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
;
47 struct eh_cie_fde
*cie_inf
;
48 unsigned char per_encoding
;
49 unsigned char lsda_encoding
;
50 unsigned char fde_encoding
;
51 unsigned char initial_insn_length
;
52 unsigned char can_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
->u
.cie
.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;
297 if (entry
->add_augmentation_size
)
299 if (entry
->cie
&& entry
->u
.cie
.add_fde_encoding
)
304 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
305 required alignment of ENTRY in bytes. */
308 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
312 if (entry
->size
== 4)
315 + extra_augmentation_string_bytes (entry
)
316 + extra_augmentation_data_bytes (entry
)
317 + alignment
- 1) & -alignment
;
320 /* Assume that the bytes between *ITER and END are CFA instructions.
321 Try to move *ITER past the first instruction and return true on
322 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
325 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
330 if (!read_byte (iter
, end
, &op
))
333 switch (op
& 0xc0 ? op
& 0xc0 : op
)
336 case DW_CFA_advance_loc
:
338 case DW_CFA_remember_state
:
339 case DW_CFA_restore_state
:
340 case DW_CFA_GNU_window_save
:
345 case DW_CFA_restore_extended
:
346 case DW_CFA_undefined
:
347 case DW_CFA_same_value
:
348 case DW_CFA_def_cfa_register
:
349 case DW_CFA_def_cfa_offset
:
350 case DW_CFA_def_cfa_offset_sf
:
351 case DW_CFA_GNU_args_size
:
352 /* One leb128 argument. */
353 return skip_leb128 (iter
, end
);
355 case DW_CFA_val_offset
:
356 case DW_CFA_val_offset_sf
:
357 case DW_CFA_offset_extended
:
358 case DW_CFA_register
:
360 case DW_CFA_offset_extended_sf
:
361 case DW_CFA_GNU_negative_offset_extended
:
362 case DW_CFA_def_cfa_sf
:
363 /* Two leb128 arguments. */
364 return (skip_leb128 (iter
, end
)
365 && skip_leb128 (iter
, end
));
367 case DW_CFA_def_cfa_expression
:
368 /* A variable-length argument. */
369 return (read_uleb128 (iter
, end
, &length
)
370 && skip_bytes (iter
, end
, length
));
372 case DW_CFA_expression
:
373 case DW_CFA_val_expression
:
374 /* A leb128 followed by a variable-length argument. */
375 return (skip_leb128 (iter
, end
)
376 && read_uleb128 (iter
, end
, &length
)
377 && skip_bytes (iter
, end
, length
));
380 return skip_bytes (iter
, end
, encoded_ptr_width
);
382 case DW_CFA_advance_loc1
:
383 return skip_bytes (iter
, end
, 1);
385 case DW_CFA_advance_loc2
:
386 return skip_bytes (iter
, end
, 2);
388 case DW_CFA_advance_loc4
:
389 return skip_bytes (iter
, end
, 4);
391 case DW_CFA_MIPS_advance_loc8
:
392 return skip_bytes (iter
, end
, 8);
399 /* Try to interpret the bytes between BUF and END as CFA instructions.
400 If every byte makes sense, return a pointer to the first DW_CFA_nop
401 padding byte, or END if there is no padding. Return null otherwise.
402 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
405 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
406 unsigned int *set_loc_count
)
412 if (*buf
== DW_CFA_nop
)
416 if (*buf
== DW_CFA_set_loc
)
418 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
425 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
426 .eh_frame section. */
429 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
431 struct eh_frame_hdr_info
*hdr_info
;
433 hdr_info
= &elf_hash_table (info
)->eh_info
;
434 if (!hdr_info
->parsed_eh_frames
&& !info
->relocatable
)
435 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
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
;
459 struct eh_cie_fde
*local_cie
;
460 } *ecies
= NULL
, *ecie
;
461 unsigned int ecie_count
;
462 struct cie
*cie
, *local_cies
= NULL
, tmp_cie
;
463 struct elf_link_hash_table
*htab
;
464 struct eh_frame_hdr_info
*hdr_info
;
465 struct eh_frame_sec_info
*sec_info
= NULL
;
466 unsigned int ptr_size
;
467 unsigned int num_cies
;
468 unsigned int num_entries
;
469 elf_gc_mark_hook_fn gc_mark_hook
;
471 htab
= elf_hash_table (info
);
472 hdr_info
= &htab
->eh_info
;
473 if (hdr_info
->parsed_eh_frames
)
478 /* This file does not contain .eh_frame information. */
482 if (bfd_is_abs_section (sec
->output_section
))
484 /* At least one of the sections is being discarded from the
485 link, so we should just ignore them. */
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);
510 /* Go through the section contents and work out how many FDEs and
513 end
= ehbuf
+ sec
->size
;
520 /* Read the length of the entry. */
521 REQUIRE (skip_bytes (&buf
, end
, 4));
522 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
524 /* 64-bit .eh_frame is not supported. */
525 REQUIRE (hdr_length
!= 0xffffffff);
529 REQUIRE (skip_bytes (&buf
, end
, 4));
530 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
534 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
537 sec_info
= bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
538 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
541 ecies
= bfd_zmalloc (num_cies
* sizeof (*ecies
));
544 /* If we're not merging CIE entries (such as for a relocatable link),
545 we need to have a "struct cie" for each CIE in this section. */
546 if (hdr_info
->cies
== NULL
)
548 local_cies
= bfd_zmalloc (num_cies
* sizeof (*local_cies
));
549 REQUIRE (local_cies
);
552 #define ENSURE_NO_RELOCS(buf) \
553 REQUIRE (!(cookie->rel < cookie->relend \
554 && (cookie->rel->r_offset \
555 < (bfd_size_type) ((buf) - ehbuf)) \
556 && cookie->rel->r_info != 0))
558 #define SKIP_RELOCS(buf) \
559 while (cookie->rel < cookie->relend \
560 && (cookie->rel->r_offset \
561 < (bfd_size_type) ((buf) - ehbuf))) \
564 #define GET_RELOC(buf) \
565 ((cookie->rel < cookie->relend \
566 && (cookie->rel->r_offset \
567 == (bfd_size_type) ((buf) - ehbuf))) \
568 ? cookie->rel : NULL)
572 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
573 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
576 bfd_byte
*start
, *insns
, *insns_end
;
577 bfd_size_type length
;
578 unsigned int set_loc_count
;
580 this_inf
= sec_info
->entry
+ sec_info
->count
;
583 /* Read the length of the entry. */
584 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
585 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
587 /* The CIE/FDE must be fully contained in this input section. */
588 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
589 end
= buf
+ hdr_length
;
591 this_inf
->offset
= last_fde
- ehbuf
;
592 this_inf
->size
= 4 + hdr_length
;
593 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
597 /* A zero-length CIE should only be found at the end of
599 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
600 ENSURE_NO_RELOCS (buf
);
605 REQUIRE (skip_bytes (&buf
, end
, 4));
606 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
610 unsigned int initial_insn_length
;
615 /* If we're merging CIEs, construct the struct cie in TMP_CIE;
616 we'll enter it into the global pool later. Otherwise point
617 CIE to one of the section-local cie structures. */
619 cie
= local_cies
+ ecie_count
;
623 memset (cie
, 0, sizeof (*cie
));
625 cie
->cie_inf
= this_inf
;
626 cie
->length
= hdr_length
;
627 cie
->output_sec
= sec
->output_section
;
629 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
631 /* Cannot handle unknown versions. */
632 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
633 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
635 strcpy (cie
->augmentation
, (char *) buf
);
636 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
637 ENSURE_NO_RELOCS (buf
);
638 if (buf
[0] == 'e' && buf
[1] == 'h')
640 /* GCC < 3.0 .eh_frame CIE */
641 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
642 is private to each CIE, so we don't need it for anything.
644 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
647 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
648 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
649 if (cie
->version
== 1)
652 cie
->ra_column
= *buf
++;
655 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
656 ENSURE_NO_RELOCS (buf
);
657 cie
->lsda_encoding
= DW_EH_PE_omit
;
658 cie
->fde_encoding
= DW_EH_PE_omit
;
659 cie
->per_encoding
= DW_EH_PE_omit
;
660 aug
= cie
->augmentation
;
661 if (aug
[0] != 'e' || aug
[1] != 'h')
666 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
667 ENSURE_NO_RELOCS (buf
);
674 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
675 ENSURE_NO_RELOCS (buf
);
676 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
679 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
680 ENSURE_NO_RELOCS (buf
);
681 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
689 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
690 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
693 if ((cie
->per_encoding
& 0xf0) == DW_EH_PE_aligned
)
695 length
= -(buf
- ehbuf
) & (per_width
- 1);
696 REQUIRE (skip_bytes (&buf
, end
, length
));
698 ENSURE_NO_RELOCS (buf
);
699 /* Ensure we have a reloc here. */
700 if (GET_RELOC (buf
) != NULL
)
702 unsigned long r_symndx
;
705 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
]
707 r_symndx
= ELF64_R_SYM (cookie
->rel
->r_info
);
710 r_symndx
= ELF32_R_SYM (cookie
->rel
->r_info
);
711 if (r_symndx
>= cookie
->locsymcount
712 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
]
713 .st_info
) != STB_LOCAL
)
715 struct elf_link_hash_entry
*h
;
717 r_symndx
-= cookie
->extsymoff
;
718 h
= cookie
->sym_hashes
[r_symndx
];
720 while (h
->root
.type
== bfd_link_hash_indirect
721 || h
->root
.type
== bfd_link_hash_warning
)
722 h
= (struct elf_link_hash_entry
*)
725 cie
->personality
.h
= h
;
729 Elf_Internal_Sym
*sym
;
733 sym
= &cookie
->locsyms
[r_symndx
];
734 sym_sec
= (bfd_section_from_elf_index
735 (abfd
, sym
->st_shndx
));
738 if (sym_sec
->kept_section
!= NULL
)
739 sym_sec
= sym_sec
->kept_section
;
740 if (sym_sec
->output_section
!= NULL
)
743 + sym_sec
->output_offset
744 + sym_sec
->output_section
->vma
);
745 cie
->personality
.val
= val
;
746 cie
->local_personality
= 1;
751 /* Cope with MIPS-style composite relocations. */
754 while (GET_RELOC (buf
) != NULL
);
756 REQUIRE (skip_bytes (&buf
, end
, per_width
));
757 REQUIRE (cie
->local_personality
|| cie
->personality
.h
);
761 /* Unrecognized augmentation. Better bail out. */
766 /* For shared libraries, try to get rid of as many RELATIVE relocs
769 && (get_elf_backend_data (abfd
)
770 ->elf_backend_can_make_relative_eh_frame
773 if ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
)
774 this_inf
->make_relative
= 1;
775 /* If the CIE doesn't already have an 'R' entry, it's fairly
776 easy to add one, provided that there's no aligned data
777 after the augmentation string. */
778 else if (cie
->fde_encoding
== DW_EH_PE_omit
779 && (cie
->per_encoding
& 0xf0) != DW_EH_PE_aligned
)
781 if (*cie
->augmentation
== 0)
782 this_inf
->add_augmentation_size
= 1;
783 this_inf
->u
.cie
.add_fde_encoding
= 1;
784 this_inf
->make_relative
= 1;
789 && (get_elf_backend_data (abfd
)
790 ->elf_backend_can_make_lsda_relative_eh_frame
792 && (cie
->lsda_encoding
& 0xf0) == DW_EH_PE_absptr
)
793 cie
->can_make_lsda_relative
= 1;
795 /* If FDE encoding was not specified, it defaults to
797 if (cie
->fde_encoding
== DW_EH_PE_omit
)
798 cie
->fde_encoding
= DW_EH_PE_absptr
;
800 initial_insn_length
= end
- buf
;
801 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
803 cie
->initial_insn_length
= initial_insn_length
;
804 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
807 buf
+= initial_insn_length
;
808 ENSURE_NO_RELOCS (buf
);
810 this_inf
->u
.cie
.per_encoding_relative
811 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
817 /* Find the corresponding CIE. */
818 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
819 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
820 if (cie_offset
== ecie
->local_cie
->offset
)
823 /* Ensure this FDE references one of the CIEs in this input
825 REQUIRE (ecie
!= ecies
+ ecie_count
);
827 this_inf
->u
.fde
.cie_inf
= ecie
->local_cie
;
828 this_inf
->make_relative
= ecie
->local_cie
->make_relative
;
829 this_inf
->add_augmentation_size
830 = ecie
->local_cie
->add_augmentation_size
;
832 ENSURE_NO_RELOCS (buf
);
833 REQUIRE (GET_RELOC (buf
));
835 /* Chain together the FDEs for each section. */
836 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
837 REQUIRE (rsec
&& rsec
->owner
== abfd
);
838 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
839 elf_fde_list (rsec
) = this_inf
;
841 /* Skip the initial location and address range. */
843 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
844 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
846 /* Skip the augmentation size, if present. */
847 if (cie
->augmentation
[0] == 'z')
848 REQUIRE (read_uleb128 (&buf
, end
, &length
));
852 /* Of the supported augmentation characters above, only 'L'
853 adds augmentation data to the FDE. This code would need to
854 be adjusted if any future augmentations do the same thing. */
855 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
858 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
859 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
860 this_inf
->lsda_offset
= buf
- start
;
861 /* If there's no 'z' augmentation, we don't know where the
862 CFA insns begin. Assume no padding. */
863 if (cie
->augmentation
[0] != 'z')
867 /* Skip over the augmentation data. */
868 REQUIRE (skip_bytes (&buf
, end
, length
));
871 buf
= last_fde
+ 4 + hdr_length
;
875 /* Try to interpret the CFA instructions and find the first
876 padding nop. Shrink this_inf's size so that it doesn't
877 include the padding. */
878 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
880 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
881 /* If we don't understand the CFA instructions, we can't know
882 what needs to be adjusted there. */
883 if (insns_end
== NULL
884 /* For the time being we don't support DW_CFA_set_loc in
886 || (set_loc_count
&& this_inf
->cie
))
888 this_inf
->size
-= end
- insns_end
;
889 if (insns_end
!= end
&& this_inf
->cie
)
891 cie
->initial_insn_length
-= end
- insns_end
;
892 cie
->length
-= end
- insns_end
;
895 && ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
896 || this_inf
->make_relative
))
901 this_inf
->set_loc
= bfd_malloc ((set_loc_count
+ 1)
902 * sizeof (unsigned int));
903 REQUIRE (this_inf
->set_loc
);
904 this_inf
->set_loc
[0] = set_loc_count
;
909 if (*p
== DW_CFA_set_loc
)
910 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
911 REQUIRE (skip_cfa_op (&p
, end
, length
));
915 this_inf
->removed
= 1;
916 this_inf
->fde_encoding
= cie
->fde_encoding
;
917 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
920 /* We have now finished constructing the struct cie. */
921 if (hdr_info
->cies
!= NULL
)
923 /* See if we can merge this CIE with an earlier one. */
926 cie_compute_hash (cie
);
927 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
,
930 if (*loc
== HTAB_EMPTY_ENTRY
)
932 *loc
= malloc (sizeof (struct cie
));
934 memcpy (*loc
, cie
, sizeof (struct cie
));
936 cie
= (struct cie
*) *loc
;
938 this_inf
->u
.cie
.u
.merged
= cie
->cie_inf
;
939 ecies
[ecie_count
].cie
= cie
;
940 ecies
[ecie_count
++].local_cie
= this_inf
;
944 BFD_ASSERT (sec_info
->count
== num_entries
);
945 BFD_ASSERT (ecie_count
== num_cies
);
947 elf_section_data (sec
)->sec_info
= sec_info
;
948 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
952 (*info
->callbacks
->einfo
)
953 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
955 hdr_info
->table
= FALSE
;
968 /* Finish a pass over all .eh_frame sections. */
971 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
973 struct eh_frame_hdr_info
*hdr_info
;
975 hdr_info
= &elf_hash_table (info
)->eh_info
;
976 if (hdr_info
->cies
!= NULL
)
978 htab_delete (hdr_info
->cies
);
979 hdr_info
->cies
= NULL
;
981 hdr_info
->parsed_eh_frames
= TRUE
;
984 /* Mark all relocations against CIE or FDE ENT, which occurs in
985 .eh_frame section SEC. COOKIE describes the relocations in SEC;
986 its "rel" field can be changed freely. */
989 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
990 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
991 struct elf_reloc_cookie
*cookie
)
993 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
994 cookie
->rel
< cookie
->relend
995 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
997 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
1003 /* Mark all the relocations against FDEs that relate to code in input
1004 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1005 relocations are described by COOKIE. */
1008 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
1009 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
1010 struct elf_reloc_cookie
*cookie
)
1012 struct eh_cie_fde
*fde
, *cie
, *merged
;
1014 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
1016 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
1019 /* At this stage, all cie_inf fields point to local CIEs, so we
1020 can use the same cookie to refer to them. */
1021 cie
= fde
->u
.fde
.cie_inf
;
1022 merged
= cie
->u
.cie
.u
.merged
;
1023 if (!merged
->u
.cie
.gc_mark
)
1025 merged
->u
.cie
.gc_mark
= 1;
1026 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
1033 /* This function is called for each input file before the .eh_frame
1034 section is relocated. It discards duplicate CIEs and FDEs for discarded
1035 functions. The function returns TRUE iff any entries have been
1039 _bfd_elf_discard_section_eh_frame
1040 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1041 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1042 struct elf_reloc_cookie
*cookie
)
1044 struct eh_cie_fde
*ent
, *cie
, *merged
;
1045 struct eh_frame_sec_info
*sec_info
;
1046 struct eh_frame_hdr_info
*hdr_info
;
1047 unsigned int ptr_size
, offset
;
1049 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1050 if (sec_info
== NULL
)
1053 hdr_info
= &elf_hash_table (info
)->eh_info
;
1054 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1057 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1058 BFD_ASSERT (cookie
->rel
< cookie
->relend
1059 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1060 if (!(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
))
1063 && (((ent
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
1064 && ent
->make_relative
== 0)
1065 || (ent
->fde_encoding
& 0xf0) == DW_EH_PE_aligned
))
1067 /* If a shared library uses absolute pointers
1068 which we cannot turn into PC relative,
1069 don't create the binary search table,
1070 since it is affected by runtime relocations. */
1071 hdr_info
->table
= FALSE
;
1072 (*info
->callbacks
->einfo
)
1073 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1074 " table being created.\n"), abfd
, sec
);
1077 hdr_info
->fde_count
++;
1079 cie
= ent
->u
.fde
.cie_inf
;
1082 merged
= cie
->u
.cie
.u
.merged
;
1083 if (!merged
->removed
)
1084 /* We have decided to keep the group representative. */
1085 ent
->u
.fde
.cie_inf
= merged
;
1086 else if (merged
->u
.cie
.u
.merged
!= merged
)
1087 /* We didn't keep the original group representative,
1088 but we did keep an alternative. */
1089 ent
->u
.fde
.cie_inf
= merged
->u
.cie
.u
.merged
;
1092 /* Make the local CIE represent the merged group. */
1093 merged
->u
.cie
.u
.merged
= cie
;
1095 cie
->u
.cie
.u
.sec
= sec
;
1096 cie
->u
.cie
.make_lsda_relative
1097 = merged
->u
.cie
.make_lsda_relative
;
1103 ptr_size
= (get_elf_backend_data (sec
->owner
)
1104 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1106 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1109 ent
->new_offset
= offset
;
1110 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1113 sec
->rawsize
= sec
->size
;
1115 return offset
!= sec
->rawsize
;
1118 /* This function is called for .eh_frame_hdr section after
1119 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1120 input sections. It finalizes the size of .eh_frame_hdr section. */
1123 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1125 struct elf_link_hash_table
*htab
;
1126 struct eh_frame_hdr_info
*hdr_info
;
1129 htab
= elf_hash_table (info
);
1130 hdr_info
= &htab
->eh_info
;
1132 sec
= hdr_info
->hdr_sec
;
1136 sec
->size
= EH_FRAME_HDR_SIZE
;
1137 if (hdr_info
->table
)
1138 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1140 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1144 /* This function is called from size_dynamic_sections.
1145 It needs to decide whether .eh_frame_hdr should be output or not,
1146 because when the dynamic symbol table has been sized it is too late
1147 to strip sections. */
1150 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1154 struct elf_link_hash_table
*htab
;
1155 struct eh_frame_hdr_info
*hdr_info
;
1157 htab
= elf_hash_table (info
);
1158 hdr_info
= &htab
->eh_info
;
1159 if (hdr_info
->hdr_sec
== NULL
)
1162 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1164 hdr_info
->hdr_sec
= NULL
;
1169 if (info
->eh_frame_hdr
)
1170 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1172 /* Count only sections which have at least a single CIE or FDE.
1173 There cannot be any CIE or FDE <= 8 bytes. */
1174 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1175 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1181 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1182 hdr_info
->hdr_sec
= NULL
;
1186 hdr_info
->table
= TRUE
;
1190 /* Adjust an address in the .eh_frame section. Given OFFSET within
1191 SEC, this returns the new offset in the adjusted .eh_frame section,
1192 or -1 if the address refers to a CIE/FDE which has been removed
1193 or to offset with dynamic relocation which is no longer needed. */
1196 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1197 struct bfd_link_info
*info
,
1201 struct eh_frame_sec_info
*sec_info
;
1202 struct elf_link_hash_table
*htab
;
1203 struct eh_frame_hdr_info
*hdr_info
;
1204 unsigned int lo
, hi
, mid
;
1206 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1208 sec_info
= elf_section_data (sec
)->sec_info
;
1210 if (offset
>= sec
->rawsize
)
1211 return offset
- sec
->rawsize
+ sec
->size
;
1213 htab
= elf_hash_table (info
);
1214 hdr_info
= &htab
->eh_info
;
1217 hi
= sec_info
->count
;
1221 mid
= (lo
+ hi
) / 2;
1222 if (offset
< sec_info
->entry
[mid
].offset
)
1225 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1231 BFD_ASSERT (lo
< hi
);
1233 /* FDE or CIE was removed. */
1234 if (sec_info
->entry
[mid
].removed
)
1235 return (bfd_vma
) -1;
1237 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1238 relocation against FDE's initial_location field. */
1239 if (!sec_info
->entry
[mid
].cie
1240 && sec_info
->entry
[mid
].make_relative
1241 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1242 return (bfd_vma
) -2;
1244 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1245 for run-time relocation against LSDA field. */
1246 if (!sec_info
->entry
[mid
].cie
1247 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1248 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1249 + sec_info
->entry
[mid
].lsda_offset
))
1250 return (bfd_vma
) -2;
1252 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1253 relocation against DW_CFA_set_loc's arguments. */
1254 if (sec_info
->entry
[mid
].set_loc
1255 && sec_info
->entry
[mid
].make_relative
1256 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1257 + sec_info
->entry
[mid
].set_loc
[1]))
1261 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1262 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1263 + sec_info
->entry
[mid
].set_loc
[cnt
])
1264 return (bfd_vma
) -2;
1267 /* Any new augmentation bytes go before the first relocation. */
1268 return (offset
+ sec_info
->entry
[mid
].new_offset
1269 - sec_info
->entry
[mid
].offset
1270 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1271 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1274 /* Write out .eh_frame section. This is called with the relocated
1278 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1279 struct bfd_link_info
*info
,
1283 struct eh_frame_sec_info
*sec_info
;
1284 struct elf_link_hash_table
*htab
;
1285 struct eh_frame_hdr_info
*hdr_info
;
1286 unsigned int ptr_size
;
1287 struct eh_cie_fde
*ent
;
1289 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1290 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1291 sec
->output_offset
, sec
->size
);
1293 ptr_size
= (get_elf_backend_data (abfd
)
1294 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1295 BFD_ASSERT (ptr_size
!= 0);
1297 sec_info
= elf_section_data (sec
)->sec_info
;
1298 htab
= elf_hash_table (info
);
1299 hdr_info
= &htab
->eh_info
;
1301 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1303 = bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1304 if (hdr_info
->array
== NULL
)
1307 /* The new offsets can be bigger or smaller than the original offsets.
1308 We therefore need to make two passes over the section: one backward
1309 pass to move entries up and one forward pass to move entries down.
1310 The two passes won't interfere with each other because entries are
1312 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1313 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1314 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1316 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1317 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1318 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1320 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1322 unsigned char *buf
, *end
;
1323 unsigned int new_size
;
1330 /* Any terminating FDE must be at the end of the section. */
1331 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1335 buf
= contents
+ ent
->new_offset
;
1336 end
= buf
+ ent
->size
;
1337 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1339 /* Update the size. It may be shrinked. */
1340 bfd_put_32 (abfd
, new_size
- 4, buf
);
1342 /* Filling the extra bytes with DW_CFA_nops. */
1343 if (new_size
!= ent
->size
)
1344 memset (end
, 0, new_size
- ent
->size
);
1349 if (ent
->make_relative
1350 || ent
->u
.cie
.make_lsda_relative
1351 || ent
->u
.cie
.per_encoding_relative
)
1354 unsigned int action
, extra_string
, extra_data
;
1355 unsigned int per_width
, per_encoding
;
1357 /* Need to find 'R' or 'L' augmentation's argument and modify
1358 DW_EH_PE_* value. */
1359 action
= ((ent
->make_relative
? 1 : 0)
1360 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1361 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1362 extra_string
= extra_augmentation_string_bytes (ent
);
1363 extra_data
= extra_augmentation_data_bytes (ent
);
1365 /* Skip length, id and version. */
1368 buf
+= strlen (aug
) + 1;
1369 skip_leb128 (&buf
, end
);
1370 skip_leb128 (&buf
, end
);
1371 skip_leb128 (&buf
, end
);
1374 /* The uleb128 will always be a single byte for the kind
1375 of augmentation strings that we're prepared to handle. */
1376 *buf
++ += extra_data
;
1380 /* Make room for the new augmentation string and data bytes. */
1381 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1382 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1383 buf
+= extra_string
;
1384 end
+= extra_string
+ extra_data
;
1386 if (ent
->add_augmentation_size
)
1389 *buf
++ = extra_data
- 1;
1391 if (ent
->u
.cie
.add_fde_encoding
)
1393 BFD_ASSERT (action
& 1);
1395 *buf
++ = DW_EH_PE_pcrel
;
1405 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1406 *buf
|= DW_EH_PE_pcrel
;
1412 per_encoding
= *buf
++;
1413 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1414 BFD_ASSERT (per_width
!= 0);
1415 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1416 == ent
->u
.cie
.per_encoding_relative
);
1417 if ((per_encoding
& 0xf0) == DW_EH_PE_aligned
)
1419 + ((buf
- contents
+ per_width
- 1)
1420 & ~((bfd_size_type
) per_width
- 1)));
1425 val
= read_value (abfd
, buf
, per_width
,
1426 get_DW_EH_PE_signed (per_encoding
));
1427 val
+= ent
->offset
- ent
->new_offset
;
1428 val
-= extra_string
+ extra_data
;
1429 write_value (abfd
, buf
, val
, per_width
);
1437 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1438 *buf
|= DW_EH_PE_pcrel
;
1453 bfd_vma value
, address
;
1456 struct eh_cie_fde
*cie
;
1459 cie
= ent
->u
.fde
.cie_inf
;
1461 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1462 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1463 bfd_put_32 (abfd
, value
, buf
);
1465 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1466 value
= read_value (abfd
, buf
, width
,
1467 get_DW_EH_PE_signed (ent
->fde_encoding
));
1471 switch (ent
->fde_encoding
& 0xf0)
1473 case DW_EH_PE_indirect
:
1474 case DW_EH_PE_textrel
:
1475 BFD_ASSERT (hdr_info
== NULL
);
1477 case DW_EH_PE_datarel
:
1479 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1481 BFD_ASSERT (got
!= NULL
);
1482 address
+= got
->vma
;
1485 case DW_EH_PE_pcrel
:
1486 value
+= ent
->offset
- ent
->new_offset
;
1487 address
+= (sec
->output_section
->vma
1488 + sec
->output_offset
1492 if (ent
->make_relative
)
1493 value
-= (sec
->output_section
->vma
1494 + sec
->output_offset
1495 + ent
->new_offset
+ 8);
1496 write_value (abfd
, buf
, value
, width
);
1503 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1504 hdr_info
->array
[hdr_info
->array_count
++].fde
1505 = (sec
->output_section
->vma
1506 + sec
->output_offset
1510 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
1511 || cie
->u
.cie
.make_lsda_relative
)
1513 buf
+= ent
->lsda_offset
;
1514 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1515 value
= read_value (abfd
, buf
, width
,
1516 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1519 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1520 value
+= ent
->offset
- ent
->new_offset
;
1521 else if (cie
->u
.cie
.make_lsda_relative
)
1522 value
-= (sec
->output_section
->vma
1523 + sec
->output_offset
1524 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1525 write_value (abfd
, buf
, value
, width
);
1528 else if (ent
->add_augmentation_size
)
1530 /* Skip the PC and length and insert a zero byte for the
1531 augmentation size. */
1533 memmove (buf
+ 1, buf
, end
- buf
);
1539 /* Adjust DW_CFA_set_loc. */
1540 unsigned int cnt
, width
;
1543 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1544 new_offset
= ent
->new_offset
+ 8
1545 + extra_augmentation_string_bytes (ent
)
1546 + extra_augmentation_data_bytes (ent
);
1548 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1551 buf
= start
+ ent
->set_loc
[cnt
];
1553 value
= read_value (abfd
, buf
, width
,
1554 get_DW_EH_PE_signed (ent
->fde_encoding
));
1558 if ((ent
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1559 value
+= ent
->offset
+ 8 - new_offset
;
1560 if (ent
->make_relative
)
1561 value
-= (sec
->output_section
->vma
1562 + sec
->output_offset
1563 + new_offset
+ ent
->set_loc
[cnt
]);
1564 write_value (abfd
, buf
, value
, width
);
1570 /* We don't align the section to its section alignment since the
1571 runtime library only expects all CIE/FDE records aligned at
1572 the pointer size. _bfd_elf_discard_section_eh_frame should
1573 have padded CIE/FDE records to multiple of pointer size with
1574 size_of_output_cie_fde. */
1575 if ((sec
->size
% ptr_size
) != 0)
1578 return bfd_set_section_contents (abfd
, sec
->output_section
,
1579 contents
, (file_ptr
) sec
->output_offset
,
1583 /* Helper function used to sort .eh_frame_hdr search table by increasing
1584 VMA of FDE initial location. */
1587 vma_compare (const void *a
, const void *b
)
1589 const struct eh_frame_array_ent
*p
= a
;
1590 const struct eh_frame_array_ent
*q
= b
;
1591 if (p
->initial_loc
> q
->initial_loc
)
1593 if (p
->initial_loc
< q
->initial_loc
)
1598 /* Write out .eh_frame_hdr section. This must be called after
1599 _bfd_elf_write_section_eh_frame has been called on all input
1601 .eh_frame_hdr format:
1602 ubyte version (currently 1)
1603 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1605 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1606 number (or DW_EH_PE_omit if there is no
1607 binary search table computed))
1608 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1609 or DW_EH_PE_omit if not present.
1610 DW_EH_PE_datarel is using address of
1611 .eh_frame_hdr section start as base)
1612 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1613 optionally followed by:
1614 [encoded] fde_count (total number of FDEs in .eh_frame section)
1615 fde_count x [encoded] initial_loc, fde
1616 (array of encoded pairs containing
1617 FDE initial_location field and FDE address,
1618 sorted by increasing initial_loc). */
1621 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1623 struct elf_link_hash_table
*htab
;
1624 struct eh_frame_hdr_info
*hdr_info
;
1627 asection
*eh_frame_sec
;
1630 bfd_vma encoded_eh_frame
;
1632 htab
= elf_hash_table (info
);
1633 hdr_info
= &htab
->eh_info
;
1634 sec
= hdr_info
->hdr_sec
;
1638 size
= EH_FRAME_HDR_SIZE
;
1639 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1640 size
+= 4 + hdr_info
->fde_count
* 8;
1641 contents
= bfd_malloc (size
);
1642 if (contents
== NULL
)
1645 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1646 if (eh_frame_sec
== NULL
)
1652 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1653 contents
[0] = 1; /* Version. */
1654 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1655 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1656 &encoded_eh_frame
); /* .eh_frame offset. */
1658 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1660 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1661 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1665 contents
[2] = DW_EH_PE_omit
;
1666 contents
[3] = DW_EH_PE_omit
;
1668 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1670 if (contents
[2] != DW_EH_PE_omit
)
1674 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1675 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1677 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1680 hdr_info
->array
[i
].initial_loc
1681 - sec
->output_section
->vma
,
1682 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1684 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1685 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1689 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1690 contents
, (file_ptr
) sec
->output_offset
,
1696 /* Return the width of FDE addresses. This is the default implementation. */
1699 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1701 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1704 /* Decide whether we can use a PC-relative encoding within the given
1705 EH frame section. This is the default implementation. */
1708 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1709 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1710 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1715 /* Select an encoding for the given address. Preference is given to
1716 PC-relative addressing modes. */
1719 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1720 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1721 asection
*osec
, bfd_vma offset
,
1722 asection
*loc_sec
, bfd_vma loc_offset
,
1725 *encoded
= osec
->vma
+ offset
-
1726 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1727 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;