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 make_relative
;
53 unsigned char can_make_lsda_relative
;
54 unsigned char initial_instructions
[50];
59 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
60 move onto the next byte. Return true on success. */
62 static inline bfd_boolean
63 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
67 *result
= *((*iter
)++);
71 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
72 Return true it was possible to move LENGTH bytes. */
74 static inline bfd_boolean
75 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
77 if ((bfd_size_type
) (end
- *iter
) < length
)
86 /* Move *ITER over an leb128, stopping at END. Return true if the end
87 of the leb128 was found. */
90 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
94 if (!read_byte (iter
, end
, &byte
))
100 /* Like skip_leb128, but treat the leb128 as an unsigned value and
101 store it in *VALUE. */
104 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
109 if (!skip_leb128 (iter
, end
))
115 *value
= (*value
<< 7) | (*--p
& 0x7f);
120 /* Like read_uleb128, but for signed values. */
123 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
128 if (!skip_leb128 (iter
, end
))
132 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
134 *value
= (*value
<< 7) | (*--p
& 0x7f);
139 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
142 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
144 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
146 if ((encoding
& 0x60) == 0x60)
149 switch (encoding
& 7)
151 case DW_EH_PE_udata2
: return 2;
152 case DW_EH_PE_udata4
: return 4;
153 case DW_EH_PE_udata8
: return 8;
154 case DW_EH_PE_absptr
: return ptr_size
;
162 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164 /* Read a width sized value from memory. */
167 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
175 value
= bfd_get_signed_16 (abfd
, buf
);
177 value
= bfd_get_16 (abfd
, buf
);
181 value
= bfd_get_signed_32 (abfd
, buf
);
183 value
= bfd_get_32 (abfd
, buf
);
187 value
= bfd_get_signed_64 (abfd
, buf
);
189 value
= bfd_get_64 (abfd
, buf
);
199 /* Store a width sized value to memory. */
202 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
206 case 2: bfd_put_16 (abfd
, value
, buf
); break;
207 case 4: bfd_put_32 (abfd
, value
, buf
); break;
208 case 8: bfd_put_64 (abfd
, value
, buf
); break;
209 default: BFD_FAIL ();
213 /* Return one if C1 and C2 CIEs can be merged. */
216 cie_eq (const void *e1
, const void *e2
)
218 const struct cie
*c1
= e1
;
219 const struct cie
*c2
= e2
;
221 if (c1
->hash
== c2
->hash
222 && c1
->length
== c2
->length
223 && c1
->version
== c2
->version
224 && c1
->local_personality
== c2
->local_personality
225 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
226 && strcmp (c1
->augmentation
, "eh") != 0
227 && c1
->code_align
== c2
->code_align
228 && c1
->data_align
== c2
->data_align
229 && c1
->ra_column
== c2
->ra_column
230 && c1
->augmentation_size
== c2
->augmentation_size
231 && memcmp (&c1
->personality
, &c2
->personality
,
232 sizeof (c1
->personality
)) == 0
233 && c1
->output_sec
== c2
->output_sec
234 && c1
->per_encoding
== c2
->per_encoding
235 && c1
->lsda_encoding
== c2
->lsda_encoding
236 && c1
->fde_encoding
== c2
->fde_encoding
237 && c1
->initial_insn_length
== c2
->initial_insn_length
238 && memcmp (c1
->initial_instructions
,
239 c2
->initial_instructions
,
240 c1
->initial_insn_length
) == 0)
247 cie_hash (const void *e
)
249 const struct cie
*c
= e
;
254 cie_compute_hash (struct cie
*c
)
257 h
= iterative_hash_object (c
->length
, h
);
258 h
= iterative_hash_object (c
->version
, h
);
259 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
260 h
= iterative_hash_object (c
->code_align
, h
);
261 h
= iterative_hash_object (c
->data_align
, h
);
262 h
= iterative_hash_object (c
->ra_column
, h
);
263 h
= iterative_hash_object (c
->augmentation_size
, h
);
264 h
= iterative_hash_object (c
->personality
, h
);
265 h
= iterative_hash_object (c
->output_sec
, h
);
266 h
= iterative_hash_object (c
->per_encoding
, h
);
267 h
= iterative_hash_object (c
->lsda_encoding
, h
);
268 h
= iterative_hash_object (c
->fde_encoding
, h
);
269 h
= iterative_hash_object (c
->initial_insn_length
, h
);
270 h
= iterative_hash (c
->initial_instructions
, c
->initial_insn_length
, h
);
275 /* Return the number of extra bytes that we'll be inserting into
276 ENTRY's augmentation string. */
278 static INLINE
unsigned int
279 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
281 unsigned int size
= 0;
284 if (entry
->add_augmentation_size
)
286 if (entry
->add_fde_encoding
)
292 /* Likewise ENTRY's augmentation data. */
294 static INLINE
unsigned int
295 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
297 unsigned int size
= 0;
300 if (entry
->add_augmentation_size
)
302 if (entry
->add_fde_encoding
)
307 if (entry
->u
.fde
.cie_inf
->add_augmentation_size
)
313 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
314 required alignment of ENTRY in bytes. */
317 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
321 if (entry
->size
== 4)
324 + extra_augmentation_string_bytes (entry
)
325 + extra_augmentation_data_bytes (entry
)
326 + alignment
- 1) & -alignment
;
329 /* Assume that the bytes between *ITER and END are CFA instructions.
330 Try to move *ITER past the first instruction and return true on
331 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
334 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
339 if (!read_byte (iter
, end
, &op
))
342 switch (op
& 0xc0 ? op
& 0xc0 : op
)
345 case DW_CFA_advance_loc
:
347 case DW_CFA_remember_state
:
348 case DW_CFA_restore_state
:
349 case DW_CFA_GNU_window_save
:
354 case DW_CFA_restore_extended
:
355 case DW_CFA_undefined
:
356 case DW_CFA_same_value
:
357 case DW_CFA_def_cfa_register
:
358 case DW_CFA_def_cfa_offset
:
359 case DW_CFA_def_cfa_offset_sf
:
360 case DW_CFA_GNU_args_size
:
361 /* One leb128 argument. */
362 return skip_leb128 (iter
, end
);
364 case DW_CFA_val_offset
:
365 case DW_CFA_val_offset_sf
:
366 case DW_CFA_offset_extended
:
367 case DW_CFA_register
:
369 case DW_CFA_offset_extended_sf
:
370 case DW_CFA_GNU_negative_offset_extended
:
371 case DW_CFA_def_cfa_sf
:
372 /* Two leb128 arguments. */
373 return (skip_leb128 (iter
, end
)
374 && skip_leb128 (iter
, end
));
376 case DW_CFA_def_cfa_expression
:
377 /* A variable-length argument. */
378 return (read_uleb128 (iter
, end
, &length
)
379 && skip_bytes (iter
, end
, length
));
381 case DW_CFA_expression
:
382 case DW_CFA_val_expression
:
383 /* A leb128 followed by a variable-length argument. */
384 return (skip_leb128 (iter
, end
)
385 && read_uleb128 (iter
, end
, &length
)
386 && skip_bytes (iter
, end
, length
));
389 return skip_bytes (iter
, end
, encoded_ptr_width
);
391 case DW_CFA_advance_loc1
:
392 return skip_bytes (iter
, end
, 1);
394 case DW_CFA_advance_loc2
:
395 return skip_bytes (iter
, end
, 2);
397 case DW_CFA_advance_loc4
:
398 return skip_bytes (iter
, end
, 4);
400 case DW_CFA_MIPS_advance_loc8
:
401 return skip_bytes (iter
, end
, 8);
408 /* Try to interpret the bytes between BUF and END as CFA instructions.
409 If every byte makes sense, return a pointer to the first DW_CFA_nop
410 padding byte, or END if there is no padding. Return null otherwise.
411 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
414 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
415 unsigned int *set_loc_count
)
421 if (*buf
== DW_CFA_nop
)
425 if (*buf
== DW_CFA_set_loc
)
427 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
434 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
435 .eh_frame section. */
438 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
440 struct eh_frame_hdr_info
*hdr_info
;
442 hdr_info
= &elf_hash_table (info
)->eh_info
;
443 if (!hdr_info
->parsed_eh_frames
&& !info
->relocatable
)
444 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
447 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
448 information in the section's sec_info field on success. COOKIE
449 describes the relocations in SEC. */
452 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
453 asection
*sec
, struct elf_reloc_cookie
*cookie
)
455 #define REQUIRE(COND) \
458 goto free_no_table; \
461 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
463 struct eh_cie_fde
*this_inf
;
464 unsigned int hdr_length
, hdr_id
;
468 struct eh_cie_fde
*local_cie
;
469 } *ecies
= NULL
, *ecie
;
470 unsigned int ecie_count
;
471 struct cie
*cie
, *local_cies
= NULL
, tmp_cie
;
472 struct elf_link_hash_table
*htab
;
473 struct eh_frame_hdr_info
*hdr_info
;
474 struct eh_frame_sec_info
*sec_info
= NULL
;
475 unsigned int ptr_size
;
476 unsigned int num_cies
;
477 unsigned int num_entries
;
478 elf_gc_mark_hook_fn gc_mark_hook
;
480 htab
= elf_hash_table (info
);
481 hdr_info
= &htab
->eh_info
;
482 if (hdr_info
->parsed_eh_frames
)
487 /* This file does not contain .eh_frame information. */
491 if (bfd_is_abs_section (sec
->output_section
))
493 /* At least one of the sections is being discarded from the
494 link, so we should just ignore them. */
498 /* Read the frame unwind information from abfd. */
500 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
503 && bfd_get_32 (abfd
, ehbuf
) == 0
504 && cookie
->rel
== cookie
->relend
)
506 /* Empty .eh_frame section. */
511 /* If .eh_frame section size doesn't fit into int, we cannot handle
512 it (it would need to use 64-bit .eh_frame format anyway). */
513 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
515 ptr_size
= (get_elf_backend_data (abfd
)
516 ->elf_backend_eh_frame_address_size (abfd
, sec
));
517 REQUIRE (ptr_size
!= 0);
519 /* Go through the section contents and work out how many FDEs and
522 end
= ehbuf
+ sec
->size
;
529 /* Read the length of the entry. */
530 REQUIRE (skip_bytes (&buf
, end
, 4));
531 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
533 /* 64-bit .eh_frame is not supported. */
534 REQUIRE (hdr_length
!= 0xffffffff);
538 REQUIRE (skip_bytes (&buf
, end
, 4));
539 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
543 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
546 sec_info
= bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
547 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
550 ecies
= bfd_zmalloc (num_cies
* sizeof (*ecies
));
553 /* If we're not merging CIE entries (such as for a relocatable link),
554 we need to have a "struct cie" for each CIE in this section. */
555 if (hdr_info
->cies
== NULL
)
557 local_cies
= bfd_zmalloc (num_cies
* sizeof (*local_cies
));
558 REQUIRE (local_cies
);
561 #define ENSURE_NO_RELOCS(buf) \
562 REQUIRE (!(cookie->rel < cookie->relend \
563 && (cookie->rel->r_offset \
564 < (bfd_size_type) ((buf) - ehbuf)) \
565 && cookie->rel->r_info != 0))
567 #define SKIP_RELOCS(buf) \
568 while (cookie->rel < cookie->relend \
569 && (cookie->rel->r_offset \
570 < (bfd_size_type) ((buf) - ehbuf))) \
573 #define GET_RELOC(buf) \
574 ((cookie->rel < cookie->relend \
575 && (cookie->rel->r_offset \
576 == (bfd_size_type) ((buf) - ehbuf))) \
577 ? cookie->rel : NULL)
581 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
582 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
585 bfd_byte
*start
, *insns
, *insns_end
;
586 bfd_size_type length
;
587 unsigned int set_loc_count
;
589 this_inf
= sec_info
->entry
+ sec_info
->count
;
592 /* Read the length of the entry. */
593 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
594 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
596 /* The CIE/FDE must be fully contained in this input section. */
597 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
598 end
= buf
+ hdr_length
;
600 this_inf
->offset
= last_fde
- ehbuf
;
601 this_inf
->size
= 4 + hdr_length
;
602 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
606 /* A zero-length CIE should only be found at the end of
608 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
609 ENSURE_NO_RELOCS (buf
);
614 REQUIRE (skip_bytes (&buf
, end
, 4));
615 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
619 unsigned int initial_insn_length
;
624 /* If we're merging CIEs, construct the struct cie in TMP_CIE;
625 we'll enter it into the global pool later. Otherwise point
626 CIE to one of the section-local cie structures. */
628 cie
= local_cies
+ ecie_count
;
632 memset (cie
, 0, sizeof (*cie
));
634 cie
->cie_inf
= this_inf
;
635 cie
->length
= hdr_length
;
636 cie
->output_sec
= sec
->output_section
;
638 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
640 /* Cannot handle unknown versions. */
641 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
642 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
644 strcpy (cie
->augmentation
, (char *) buf
);
645 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
646 ENSURE_NO_RELOCS (buf
);
647 if (buf
[0] == 'e' && buf
[1] == 'h')
649 /* GCC < 3.0 .eh_frame CIE */
650 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
651 is private to each CIE, so we don't need it for anything.
653 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
656 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
657 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
658 if (cie
->version
== 1)
661 cie
->ra_column
= *buf
++;
664 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
665 ENSURE_NO_RELOCS (buf
);
666 cie
->lsda_encoding
= DW_EH_PE_omit
;
667 cie
->fde_encoding
= DW_EH_PE_omit
;
668 cie
->per_encoding
= DW_EH_PE_omit
;
669 aug
= cie
->augmentation
;
670 if (aug
[0] != 'e' || aug
[1] != 'h')
675 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
676 ENSURE_NO_RELOCS (buf
);
683 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
684 ENSURE_NO_RELOCS (buf
);
685 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
688 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
689 ENSURE_NO_RELOCS (buf
);
690 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
698 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
699 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
702 if ((cie
->per_encoding
& 0xf0) == DW_EH_PE_aligned
)
704 length
= -(buf
- ehbuf
) & (per_width
- 1);
705 REQUIRE (skip_bytes (&buf
, end
, length
));
707 ENSURE_NO_RELOCS (buf
);
708 /* Ensure we have a reloc here. */
709 if (GET_RELOC (buf
) != NULL
)
711 unsigned long r_symndx
;
714 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
]
716 r_symndx
= ELF64_R_SYM (cookie
->rel
->r_info
);
719 r_symndx
= ELF32_R_SYM (cookie
->rel
->r_info
);
720 if (r_symndx
>= cookie
->locsymcount
721 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
]
722 .st_info
) != STB_LOCAL
)
724 struct elf_link_hash_entry
*h
;
726 r_symndx
-= cookie
->extsymoff
;
727 h
= cookie
->sym_hashes
[r_symndx
];
729 while (h
->root
.type
== bfd_link_hash_indirect
730 || h
->root
.type
== bfd_link_hash_warning
)
731 h
= (struct elf_link_hash_entry
*)
734 cie
->personality
.h
= h
;
738 Elf_Internal_Sym
*sym
;
742 sym
= &cookie
->locsyms
[r_symndx
];
743 sym_sec
= (bfd_section_from_elf_index
744 (abfd
, sym
->st_shndx
));
747 if (sym_sec
->kept_section
!= NULL
)
748 sym_sec
= sym_sec
->kept_section
;
749 if (sym_sec
->output_section
!= NULL
)
752 + sym_sec
->output_offset
753 + sym_sec
->output_section
->vma
);
754 cie
->personality
.val
= val
;
755 cie
->local_personality
= 1;
760 /* Cope with MIPS-style composite relocations. */
763 while (GET_RELOC (buf
) != NULL
);
765 REQUIRE (skip_bytes (&buf
, end
, per_width
));
766 REQUIRE (cie
->local_personality
|| cie
->personality
.h
);
770 /* Unrecognized augmentation. Better bail out. */
775 /* For shared libraries, try to get rid of as many RELATIVE relocs
778 && (get_elf_backend_data (abfd
)
779 ->elf_backend_can_make_relative_eh_frame
782 if ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
)
783 cie
->make_relative
= 1;
784 /* If the CIE doesn't already have an 'R' entry, it's fairly
785 easy to add one, provided that there's no aligned data
786 after the augmentation string. */
787 else if (cie
->fde_encoding
== DW_EH_PE_omit
788 && (cie
->per_encoding
& 0xf0) != DW_EH_PE_aligned
)
790 if (*cie
->augmentation
== 0)
791 this_inf
->add_augmentation_size
= 1;
792 this_inf
->add_fde_encoding
= 1;
793 cie
->make_relative
= 1;
798 && (get_elf_backend_data (abfd
)
799 ->elf_backend_can_make_lsda_relative_eh_frame
801 && (cie
->lsda_encoding
& 0xf0) == DW_EH_PE_absptr
)
802 cie
->can_make_lsda_relative
= 1;
804 /* If FDE encoding was not specified, it defaults to
806 if (cie
->fde_encoding
== DW_EH_PE_omit
)
807 cie
->fde_encoding
= DW_EH_PE_absptr
;
809 initial_insn_length
= end
- buf
;
810 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
812 cie
->initial_insn_length
= initial_insn_length
;
813 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
816 buf
+= initial_insn_length
;
817 ENSURE_NO_RELOCS (buf
);
819 this_inf
->make_relative
= cie
->make_relative
;
820 this_inf
->per_encoding_relative
821 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
827 /* Find the corresponding CIE. */
828 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
829 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
830 if (cie_offset
== ecie
->local_cie
->offset
)
833 /* Ensure this FDE references one of the CIEs in this input
835 REQUIRE (ecie
!= ecies
+ ecie_count
);
837 this_inf
->u
.fde
.cie_inf
= ecie
->local_cie
;
839 ENSURE_NO_RELOCS (buf
);
840 REQUIRE (GET_RELOC (buf
));
842 /* Chain together the FDEs for each section. */
843 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
844 REQUIRE (rsec
&& rsec
->owner
== abfd
);
845 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
846 elf_fde_list (rsec
) = this_inf
;
848 /* Skip the initial location and address range. */
850 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
851 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
853 /* Skip the augmentation size, if present. */
854 if (cie
->augmentation
[0] == 'z')
855 REQUIRE (read_uleb128 (&buf
, end
, &length
));
859 /* Of the supported augmentation characters above, only 'L'
860 adds augmentation data to the FDE. This code would need to
861 be adjusted if any future augmentations do the same thing. */
862 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
865 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
866 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
867 this_inf
->lsda_offset
= buf
- start
;
868 /* If there's no 'z' augmentation, we don't know where the
869 CFA insns begin. Assume no padding. */
870 if (cie
->augmentation
[0] != 'z')
874 /* Skip over the augmentation data. */
875 REQUIRE (skip_bytes (&buf
, end
, length
));
878 buf
= last_fde
+ 4 + hdr_length
;
882 /* Try to interpret the CFA instructions and find the first
883 padding nop. Shrink this_inf's size so that it doesn't
884 include the padding. */
885 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
887 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
888 /* If we don't understand the CFA instructions, we can't know
889 what needs to be adjusted there. */
890 if (insns_end
== NULL
891 /* For the time being we don't support DW_CFA_set_loc in
893 || (set_loc_count
&& this_inf
->cie
))
895 this_inf
->size
-= end
- insns_end
;
896 if (insns_end
!= end
&& this_inf
->cie
)
898 cie
->initial_insn_length
-= end
- insns_end
;
899 cie
->length
-= end
- insns_end
;
902 && ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
903 || cie
->make_relative
))
908 this_inf
->set_loc
= bfd_malloc ((set_loc_count
+ 1)
909 * sizeof (unsigned int));
910 REQUIRE (this_inf
->set_loc
);
911 this_inf
->set_loc
[0] = set_loc_count
;
916 if (*p
== DW_CFA_set_loc
)
917 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
918 REQUIRE (skip_cfa_op (&p
, end
, length
));
922 this_inf
->removed
= 1;
923 this_inf
->fde_encoding
= cie
->fde_encoding
;
924 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
927 /* We have now finished constructing the struct cie. */
928 if (hdr_info
->cies
!= NULL
)
930 /* See if we can merge this CIE with an earlier one. */
933 cie_compute_hash (cie
);
934 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
,
937 if (*loc
== HTAB_EMPTY_ENTRY
)
939 *loc
= malloc (sizeof (struct cie
));
941 memcpy (*loc
, cie
, sizeof (struct cie
));
943 cie
= (struct cie
*) *loc
;
945 this_inf
->u
.cie
.merged
= cie
->cie_inf
;
946 ecies
[ecie_count
].cie
= cie
;
947 ecies
[ecie_count
++].local_cie
= this_inf
;
951 BFD_ASSERT (sec_info
->count
== num_entries
);
952 BFD_ASSERT (ecie_count
== num_cies
);
954 elf_section_data (sec
)->sec_info
= sec_info
;
955 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
959 (*info
->callbacks
->einfo
)
960 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
962 hdr_info
->table
= FALSE
;
975 /* Finish a pass over all .eh_frame sections. */
978 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
980 struct eh_frame_hdr_info
*hdr_info
;
982 hdr_info
= &elf_hash_table (info
)->eh_info
;
983 if (hdr_info
->cies
!= NULL
)
985 htab_delete (hdr_info
->cies
);
986 hdr_info
->cies
= NULL
;
988 hdr_info
->parsed_eh_frames
= TRUE
;
991 /* Mark all relocations against CIE or FDE ENT, which occurs in
992 .eh_frame section SEC. COOKIE describes the relocations in SEC;
993 its "rel" field can be changed freely. */
996 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
997 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
998 struct elf_reloc_cookie
*cookie
)
1000 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1001 cookie
->rel
< cookie
->relend
1002 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
1004 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
1010 /* Mark all the relocations against FDEs that relate to code in input
1011 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1012 relocations are described by COOKIE. */
1015 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
1016 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
1017 struct elf_reloc_cookie
*cookie
)
1019 struct eh_cie_fde
*fde
, *cie
, *merged
;
1021 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
1023 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
1026 /* At this stage, all cie_inf fields point to local CIEs, so we
1027 can use the same cookie to refer to them. */
1028 cie
= fde
->u
.fde
.cie_inf
;
1029 merged
= cie
->u
.cie
.merged
;
1030 if (!merged
->u
.cie
.gc_mark
)
1032 merged
->u
.cie
.gc_mark
= 1;
1033 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
1040 /* This function is called for each input file before the .eh_frame
1041 section is relocated. It discards duplicate CIEs and FDEs for discarded
1042 functions. The function returns TRUE iff any entries have been
1046 _bfd_elf_discard_section_eh_frame
1047 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1048 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1049 struct elf_reloc_cookie
*cookie
)
1051 struct eh_cie_fde
*ent
, *cie
, *merged
;
1052 struct eh_frame_sec_info
*sec_info
;
1053 struct eh_frame_hdr_info
*hdr_info
;
1054 unsigned int ptr_size
, offset
;
1056 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1057 if (sec_info
== NULL
)
1060 hdr_info
= &elf_hash_table (info
)->eh_info
;
1061 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1064 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1065 BFD_ASSERT (cookie
->rel
< cookie
->relend
1066 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1067 if (!(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
))
1070 && (((ent
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
1071 && ent
->u
.fde
.cie_inf
->make_relative
== 0)
1072 || (ent
->fde_encoding
& 0xf0) == DW_EH_PE_aligned
))
1074 /* If a shared library uses absolute pointers
1075 which we cannot turn into PC relative,
1076 don't create the binary search table,
1077 since it is affected by runtime relocations. */
1078 hdr_info
->table
= FALSE
;
1079 (*info
->callbacks
->einfo
)
1080 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1081 " table being created.\n"), abfd
, sec
);
1084 hdr_info
->fde_count
++;
1086 cie
= ent
->u
.fde
.cie_inf
;
1089 merged
= cie
->u
.cie
.merged
;
1090 if (!merged
->removed
)
1091 /* We have decided to keep the group representative. */
1092 ent
->u
.fde
.cie_inf
= merged
;
1093 else if (merged
->u
.cie
.merged
!= merged
)
1094 /* We didn't keep the original group representative,
1095 but we did keep an alternative. */
1096 ent
->u
.fde
.cie_inf
= merged
->u
.cie
.merged
;
1099 /* Make the local CIE represent the merged group. */
1100 merged
->u
.cie
.merged
= cie
;
1102 cie
->u
.cie
.make_lsda_relative
1103 = merged
->u
.cie
.make_lsda_relative
;
1109 ptr_size
= (get_elf_backend_data (sec
->owner
)
1110 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1112 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1115 ent
->new_offset
= offset
;
1116 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1119 sec
->rawsize
= sec
->size
;
1121 return offset
!= sec
->rawsize
;
1124 /* This function is called for .eh_frame_hdr section after
1125 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1126 input sections. It finalizes the size of .eh_frame_hdr section. */
1129 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1131 struct elf_link_hash_table
*htab
;
1132 struct eh_frame_hdr_info
*hdr_info
;
1135 htab
= elf_hash_table (info
);
1136 hdr_info
= &htab
->eh_info
;
1138 sec
= hdr_info
->hdr_sec
;
1142 sec
->size
= EH_FRAME_HDR_SIZE
;
1143 if (hdr_info
->table
)
1144 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1146 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1150 /* This function is called from size_dynamic_sections.
1151 It needs to decide whether .eh_frame_hdr should be output or not,
1152 because when the dynamic symbol table has been sized it is too late
1153 to strip sections. */
1156 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1160 struct elf_link_hash_table
*htab
;
1161 struct eh_frame_hdr_info
*hdr_info
;
1163 htab
= elf_hash_table (info
);
1164 hdr_info
= &htab
->eh_info
;
1165 if (hdr_info
->hdr_sec
== NULL
)
1168 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1170 hdr_info
->hdr_sec
= NULL
;
1175 if (info
->eh_frame_hdr
)
1176 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1178 /* Count only sections which have at least a single CIE or FDE.
1179 There cannot be any CIE or FDE <= 8 bytes. */
1180 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1181 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1187 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1188 hdr_info
->hdr_sec
= NULL
;
1192 hdr_info
->table
= TRUE
;
1196 /* Adjust an address in the .eh_frame section. Given OFFSET within
1197 SEC, this returns the new offset in the adjusted .eh_frame section,
1198 or -1 if the address refers to a CIE/FDE which has been removed
1199 or to offset with dynamic relocation which is no longer needed. */
1202 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1203 struct bfd_link_info
*info
,
1207 struct eh_frame_sec_info
*sec_info
;
1208 struct elf_link_hash_table
*htab
;
1209 struct eh_frame_hdr_info
*hdr_info
;
1210 unsigned int lo
, hi
, mid
;
1212 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1214 sec_info
= elf_section_data (sec
)->sec_info
;
1216 if (offset
>= sec
->rawsize
)
1217 return offset
- sec
->rawsize
+ sec
->size
;
1219 htab
= elf_hash_table (info
);
1220 hdr_info
= &htab
->eh_info
;
1221 if (hdr_info
->offsets_adjusted
)
1222 offset
+= sec
->output_offset
;
1225 hi
= sec_info
->count
;
1229 mid
= (lo
+ hi
) / 2;
1230 if (offset
< sec_info
->entry
[mid
].offset
)
1233 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1239 BFD_ASSERT (lo
< hi
);
1241 /* FDE or CIE was removed. */
1242 if (sec_info
->entry
[mid
].removed
)
1243 return (bfd_vma
) -1;
1245 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1246 relocation against FDE's initial_location field. */
1247 if (!sec_info
->entry
[mid
].cie
1248 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->make_relative
1249 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1250 return (bfd_vma
) -2;
1252 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1253 for run-time relocation against LSDA field. */
1254 if (!sec_info
->entry
[mid
].cie
1255 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1256 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1257 + sec_info
->entry
[mid
].lsda_offset
))
1258 return (bfd_vma
) -2;
1260 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1261 relocation against DW_CFA_set_loc's arguments. */
1262 if (sec_info
->entry
[mid
].set_loc
1263 && (sec_info
->entry
[mid
].cie
1264 ? sec_info
->entry
[mid
].make_relative
1265 : sec_info
->entry
[mid
].u
.fde
.cie_inf
->make_relative
)
1266 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1267 + sec_info
->entry
[mid
].set_loc
[1]))
1271 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1272 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1273 + sec_info
->entry
[mid
].set_loc
[cnt
])
1274 return (bfd_vma
) -2;
1277 if (hdr_info
->offsets_adjusted
)
1278 offset
-= sec
->output_offset
;
1279 /* Any new augmentation bytes go before the first relocation. */
1280 return (offset
+ sec_info
->entry
[mid
].new_offset
1281 - sec_info
->entry
[mid
].offset
1282 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1283 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1286 /* Write out .eh_frame section. This is called with the relocated
1290 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1291 struct bfd_link_info
*info
,
1295 struct eh_frame_sec_info
*sec_info
;
1296 struct elf_link_hash_table
*htab
;
1297 struct eh_frame_hdr_info
*hdr_info
;
1298 unsigned int ptr_size
;
1299 struct eh_cie_fde
*ent
;
1301 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1302 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1303 sec
->output_offset
, sec
->size
);
1305 ptr_size
= (get_elf_backend_data (abfd
)
1306 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1307 BFD_ASSERT (ptr_size
!= 0);
1309 sec_info
= elf_section_data (sec
)->sec_info
;
1310 htab
= elf_hash_table (info
);
1311 hdr_info
= &htab
->eh_info
;
1313 /* First convert all offsets to output section offsets, so that a
1314 CIE offset is valid if the CIE is used by a FDE from some other
1315 section. This can happen when duplicate CIEs are deleted in
1316 _bfd_elf_discard_section_eh_frame. We do all sections here because
1317 this function might not be called on sections in the same order as
1318 _bfd_elf_discard_section_eh_frame. */
1319 if (!hdr_info
->offsets_adjusted
)
1323 struct eh_frame_sec_info
*eh_inf
;
1325 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1327 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1328 || (ibfd
->flags
& DYNAMIC
) != 0)
1331 eh
= bfd_get_section_by_name (ibfd
, ".eh_frame");
1332 if (eh
== NULL
|| eh
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1335 eh_inf
= elf_section_data (eh
)->sec_info
;
1336 for (ent
= eh_inf
->entry
; ent
< eh_inf
->entry
+ eh_inf
->count
; ++ent
)
1338 ent
->offset
+= eh
->output_offset
;
1339 ent
->new_offset
+= eh
->output_offset
;
1342 hdr_info
->offsets_adjusted
= TRUE
;
1345 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1347 = bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1348 if (hdr_info
->array
== NULL
)
1351 /* The new offsets can be bigger or smaller than the original offsets.
1352 We therefore need to make two passes over the section: one backward
1353 pass to move entries up and one forward pass to move entries down.
1354 The two passes won't interfere with each other because entries are
1356 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1357 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1358 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1359 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1361 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1362 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1363 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1364 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1366 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1368 unsigned char *buf
, *end
;
1369 unsigned int new_size
;
1376 /* Any terminating FDE must be at the end of the section. */
1377 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1381 buf
= contents
+ ent
->new_offset
- sec
->output_offset
;
1382 end
= buf
+ ent
->size
;
1383 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1385 /* Update the size. It may be shrinked. */
1386 bfd_put_32 (abfd
, new_size
- 4, buf
);
1388 /* Filling the extra bytes with DW_CFA_nops. */
1389 if (new_size
!= ent
->size
)
1390 memset (end
, 0, new_size
- ent
->size
);
1395 if (ent
->make_relative
1396 || ent
->u
.cie
.make_lsda_relative
1397 || ent
->per_encoding_relative
)
1400 unsigned int action
, extra_string
, extra_data
;
1401 unsigned int per_width
, per_encoding
;
1403 /* Need to find 'R' or 'L' augmentation's argument and modify
1404 DW_EH_PE_* value. */
1405 action
= ((ent
->make_relative
? 1 : 0)
1406 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1407 | (ent
->per_encoding_relative
? 4 : 0));
1408 extra_string
= extra_augmentation_string_bytes (ent
);
1409 extra_data
= extra_augmentation_data_bytes (ent
);
1411 /* Skip length, id and version. */
1414 buf
+= strlen (aug
) + 1;
1415 skip_leb128 (&buf
, end
);
1416 skip_leb128 (&buf
, end
);
1417 skip_leb128 (&buf
, end
);
1420 /* The uleb128 will always be a single byte for the kind
1421 of augmentation strings that we're prepared to handle. */
1422 *buf
++ += extra_data
;
1426 /* Make room for the new augmentation string and data bytes. */
1427 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1428 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1429 buf
+= extra_string
;
1430 end
+= extra_string
+ extra_data
;
1432 if (ent
->add_augmentation_size
)
1435 *buf
++ = extra_data
- 1;
1437 if (ent
->add_fde_encoding
)
1439 BFD_ASSERT (action
& 1);
1441 *buf
++ = DW_EH_PE_pcrel
;
1451 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1452 *buf
|= DW_EH_PE_pcrel
;
1458 per_encoding
= *buf
++;
1459 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1460 BFD_ASSERT (per_width
!= 0);
1461 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1462 == ent
->per_encoding_relative
);
1463 if ((per_encoding
& 0xf0) == DW_EH_PE_aligned
)
1465 + ((buf
- contents
+ per_width
- 1)
1466 & ~((bfd_size_type
) per_width
- 1)));
1471 val
= read_value (abfd
, buf
, per_width
,
1472 get_DW_EH_PE_signed (per_encoding
));
1473 val
+= ent
->offset
- ent
->new_offset
;
1474 val
-= extra_string
+ extra_data
;
1475 write_value (abfd
, buf
, val
, per_width
);
1483 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1484 *buf
|= DW_EH_PE_pcrel
;
1499 bfd_vma value
, address
;
1502 struct eh_cie_fde
*cie
;
1505 cie
= ent
->u
.fde
.cie_inf
;
1507 value
= ent
->new_offset
+ 4 - cie
->new_offset
;
1508 bfd_put_32 (abfd
, value
, buf
);
1510 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1511 value
= read_value (abfd
, buf
, width
,
1512 get_DW_EH_PE_signed (ent
->fde_encoding
));
1516 switch (ent
->fde_encoding
& 0xf0)
1518 case DW_EH_PE_indirect
:
1519 case DW_EH_PE_textrel
:
1520 BFD_ASSERT (hdr_info
== NULL
);
1522 case DW_EH_PE_datarel
:
1524 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1526 BFD_ASSERT (got
!= NULL
);
1527 address
+= got
->vma
;
1530 case DW_EH_PE_pcrel
:
1531 value
+= ent
->offset
- ent
->new_offset
;
1532 address
+= sec
->output_section
->vma
+ ent
->offset
+ 8;
1535 if (cie
->make_relative
)
1536 value
-= sec
->output_section
->vma
+ ent
->new_offset
+ 8;
1537 write_value (abfd
, buf
, value
, width
);
1544 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1545 hdr_info
->array
[hdr_info
->array_count
++].fde
1546 = sec
->output_section
->vma
+ ent
->new_offset
;
1549 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
1550 || cie
->u
.cie
.make_lsda_relative
)
1552 buf
+= ent
->lsda_offset
;
1553 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1554 value
= read_value (abfd
, buf
, width
,
1555 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1558 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1559 value
+= ent
->offset
- ent
->new_offset
;
1560 else if (cie
->u
.cie
.make_lsda_relative
)
1561 value
-= (sec
->output_section
->vma
+ ent
->new_offset
+ 8
1562 + ent
->lsda_offset
);
1563 write_value (abfd
, buf
, value
, width
);
1566 else if (cie
->add_augmentation_size
)
1568 /* Skip the PC and length and insert a zero byte for the
1569 augmentation size. */
1571 memmove (buf
+ 1, buf
, end
- buf
);
1577 /* Adjust DW_CFA_set_loc. */
1578 unsigned int cnt
, width
;
1581 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1582 new_offset
= ent
->new_offset
+ 8
1583 + extra_augmentation_string_bytes (ent
)
1584 + extra_augmentation_data_bytes (ent
);
1586 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1589 buf
= start
+ ent
->set_loc
[cnt
];
1591 value
= read_value (abfd
, buf
, width
,
1592 get_DW_EH_PE_signed (ent
->fde_encoding
));
1596 if ((ent
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1597 value
+= ent
->offset
+ 8 - new_offset
;
1598 if (cie
->make_relative
)
1599 value
-= sec
->output_section
->vma
+ new_offset
1600 + ent
->set_loc
[cnt
];
1601 write_value (abfd
, buf
, value
, width
);
1607 /* We don't align the section to its section alignment since the
1608 runtime library only expects all CIE/FDE records aligned at
1609 the pointer size. _bfd_elf_discard_section_eh_frame should
1610 have padded CIE/FDE records to multiple of pointer size with
1611 size_of_output_cie_fde. */
1612 if ((sec
->size
% ptr_size
) != 0)
1615 return bfd_set_section_contents (abfd
, sec
->output_section
,
1616 contents
, (file_ptr
) sec
->output_offset
,
1620 /* Helper function used to sort .eh_frame_hdr search table by increasing
1621 VMA of FDE initial location. */
1624 vma_compare (const void *a
, const void *b
)
1626 const struct eh_frame_array_ent
*p
= a
;
1627 const struct eh_frame_array_ent
*q
= b
;
1628 if (p
->initial_loc
> q
->initial_loc
)
1630 if (p
->initial_loc
< q
->initial_loc
)
1635 /* Write out .eh_frame_hdr section. This must be called after
1636 _bfd_elf_write_section_eh_frame has been called on all input
1638 .eh_frame_hdr format:
1639 ubyte version (currently 1)
1640 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1642 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1643 number (or DW_EH_PE_omit if there is no
1644 binary search table computed))
1645 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1646 or DW_EH_PE_omit if not present.
1647 DW_EH_PE_datarel is using address of
1648 .eh_frame_hdr section start as base)
1649 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1650 optionally followed by:
1651 [encoded] fde_count (total number of FDEs in .eh_frame section)
1652 fde_count x [encoded] initial_loc, fde
1653 (array of encoded pairs containing
1654 FDE initial_location field and FDE address,
1655 sorted by increasing initial_loc). */
1658 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1660 struct elf_link_hash_table
*htab
;
1661 struct eh_frame_hdr_info
*hdr_info
;
1664 asection
*eh_frame_sec
;
1667 bfd_vma encoded_eh_frame
;
1669 htab
= elf_hash_table (info
);
1670 hdr_info
= &htab
->eh_info
;
1671 sec
= hdr_info
->hdr_sec
;
1675 size
= EH_FRAME_HDR_SIZE
;
1676 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1677 size
+= 4 + hdr_info
->fde_count
* 8;
1678 contents
= bfd_malloc (size
);
1679 if (contents
== NULL
)
1682 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1683 if (eh_frame_sec
== NULL
)
1689 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1690 contents
[0] = 1; /* Version. */
1691 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1692 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1693 &encoded_eh_frame
); /* .eh_frame offset. */
1695 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1697 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1698 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1702 contents
[2] = DW_EH_PE_omit
;
1703 contents
[3] = DW_EH_PE_omit
;
1705 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1707 if (contents
[2] != DW_EH_PE_omit
)
1711 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1712 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1714 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1717 hdr_info
->array
[i
].initial_loc
1718 - sec
->output_section
->vma
,
1719 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1721 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1722 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1726 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1727 contents
, (file_ptr
) sec
->output_offset
,
1733 /* Return the width of FDE addresses. This is the default implementation. */
1736 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1738 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1741 /* Decide whether we can use a PC-relative encoding within the given
1742 EH frame section. This is the default implementation. */
1745 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1746 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1747 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1752 /* Select an encoding for the given address. Preference is given to
1753 PC-relative addressing modes. */
1756 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1757 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1758 asection
*osec
, bfd_vma offset
,
1759 asection
*loc_sec
, bfd_vma loc_offset
,
1762 *encoded
= osec
->vma
+ offset
-
1763 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1764 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;