1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Written by Jakub Jelinek <jakub@redhat.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
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
;
47 unsigned int reloc_index
;
50 struct eh_cie_fde
*cie_inf
;
51 unsigned char per_encoding
;
52 unsigned char lsda_encoding
;
53 unsigned char fde_encoding
;
54 unsigned char initial_insn_length
;
55 unsigned char can_make_lsda_relative
;
56 unsigned char initial_instructions
[50];
61 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
62 move onto the next byte. Return true on success. */
64 static inline bfd_boolean
65 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
69 *result
= *((*iter
)++);
73 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
74 Return true it was possible to move LENGTH bytes. */
76 static inline bfd_boolean
77 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
79 if ((bfd_size_type
) (end
- *iter
) < length
)
88 /* Move *ITER over an leb128, stopping at END. Return true if the end
89 of the leb128 was found. */
92 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
96 if (!read_byte (iter
, end
, &byte
))
102 /* Like skip_leb128, but treat the leb128 as an unsigned value and
103 store it in *VALUE. */
106 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
111 if (!skip_leb128 (iter
, end
))
117 *value
= (*value
<< 7) | (*--p
& 0x7f);
122 /* Like read_uleb128, but for signed values. */
125 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
130 if (!skip_leb128 (iter
, end
))
134 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
136 *value
= (*value
<< 7) | (*--p
& 0x7f);
141 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
144 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
146 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
148 if ((encoding
& 0x60) == 0x60)
151 switch (encoding
& 7)
153 case DW_EH_PE_udata2
: return 2;
154 case DW_EH_PE_udata4
: return 4;
155 case DW_EH_PE_udata8
: return 8;
156 case DW_EH_PE_absptr
: return ptr_size
;
164 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
166 /* Read a width sized value from memory. */
169 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
177 value
= bfd_get_signed_16 (abfd
, buf
);
179 value
= bfd_get_16 (abfd
, buf
);
183 value
= bfd_get_signed_32 (abfd
, buf
);
185 value
= bfd_get_32 (abfd
, buf
);
189 value
= bfd_get_signed_64 (abfd
, buf
);
191 value
= bfd_get_64 (abfd
, buf
);
201 /* Store a width sized value to memory. */
204 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
208 case 2: bfd_put_16 (abfd
, value
, buf
); break;
209 case 4: bfd_put_32 (abfd
, value
, buf
); break;
210 case 8: bfd_put_64 (abfd
, value
, buf
); break;
211 default: BFD_FAIL ();
215 /* Return one if C1 and C2 CIEs can be merged. */
218 cie_eq (const void *e1
, const void *e2
)
220 const struct cie
*c1
= (const struct cie
*) e1
;
221 const struct cie
*c2
= (const struct cie
*) e2
;
223 if (c1
->hash
== c2
->hash
224 && c1
->length
== c2
->length
225 && c1
->version
== c2
->version
226 && c1
->local_personality
== c2
->local_personality
227 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
228 && strcmp (c1
->augmentation
, "eh") != 0
229 && c1
->code_align
== c2
->code_align
230 && c1
->data_align
== c2
->data_align
231 && c1
->ra_column
== c2
->ra_column
232 && c1
->augmentation_size
== c2
->augmentation_size
233 && memcmp (&c1
->personality
, &c2
->personality
,
234 sizeof (c1
->personality
)) == 0
235 && c1
->output_sec
== c2
->output_sec
236 && c1
->per_encoding
== c2
->per_encoding
237 && c1
->lsda_encoding
== c2
->lsda_encoding
238 && c1
->fde_encoding
== c2
->fde_encoding
239 && c1
->initial_insn_length
== c2
->initial_insn_length
240 && c1
->initial_insn_length
<= sizeof (c1
->initial_instructions
)
241 && memcmp (c1
->initial_instructions
,
242 c2
->initial_instructions
,
243 c1
->initial_insn_length
) == 0)
250 cie_hash (const void *e
)
252 const struct cie
*c
= (const struct cie
*) e
;
257 cie_compute_hash (struct cie
*c
)
261 h
= iterative_hash_object (c
->length
, h
);
262 h
= iterative_hash_object (c
->version
, h
);
263 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
264 h
= iterative_hash_object (c
->code_align
, h
);
265 h
= iterative_hash_object (c
->data_align
, h
);
266 h
= iterative_hash_object (c
->ra_column
, h
);
267 h
= iterative_hash_object (c
->augmentation_size
, h
);
268 h
= iterative_hash_object (c
->personality
, h
);
269 h
= iterative_hash_object (c
->output_sec
, h
);
270 h
= iterative_hash_object (c
->per_encoding
, h
);
271 h
= iterative_hash_object (c
->lsda_encoding
, h
);
272 h
= iterative_hash_object (c
->fde_encoding
, h
);
273 h
= iterative_hash_object (c
->initial_insn_length
, h
);
274 len
= c
->initial_insn_length
;
275 if (len
> sizeof (c
->initial_instructions
))
276 len
= sizeof (c
->initial_instructions
);
277 h
= iterative_hash (c
->initial_instructions
, len
, h
);
282 /* Return the number of extra bytes that we'll be inserting into
283 ENTRY's augmentation string. */
285 static INLINE
unsigned int
286 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
288 unsigned int size
= 0;
291 if (entry
->add_augmentation_size
)
293 if (entry
->u
.cie
.add_fde_encoding
)
299 /* Likewise ENTRY's augmentation data. */
301 static INLINE
unsigned int
302 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
304 unsigned int size
= 0;
305 if (entry
->add_augmentation_size
)
307 if (entry
->cie
&& entry
->u
.cie
.add_fde_encoding
)
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 /* Convert absolute encoding ENCODING into PC-relative form.
434 SIZE is the size of a pointer. */
437 make_pc_relative (unsigned char encoding
, unsigned int ptr_size
)
439 if ((encoding
& 0x7f) == DW_EH_PE_absptr
)
443 encoding
|= DW_EH_PE_sdata2
;
446 encoding
|= DW_EH_PE_sdata4
;
449 encoding
|= DW_EH_PE_sdata8
;
452 return encoding
| DW_EH_PE_pcrel
;
455 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
456 .eh_frame section. */
459 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
461 struct eh_frame_hdr_info
*hdr_info
;
463 hdr_info
= &elf_hash_table (info
)->eh_info
;
464 hdr_info
->merge_cies
= !info
->relocatable
;
467 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
468 information in the section's sec_info field on success. COOKIE
469 describes the relocations in SEC. */
472 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
473 asection
*sec
, struct elf_reloc_cookie
*cookie
)
475 #define REQUIRE(COND) \
478 goto free_no_table; \
481 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
483 struct eh_cie_fde
*this_inf
;
484 unsigned int hdr_length
, hdr_id
;
485 unsigned int cie_count
;
486 struct cie
*cie
, *local_cies
= NULL
;
487 struct elf_link_hash_table
*htab
;
488 struct eh_frame_hdr_info
*hdr_info
;
489 struct eh_frame_sec_info
*sec_info
= NULL
;
490 unsigned int ptr_size
;
491 unsigned int num_cies
;
492 unsigned int num_entries
;
493 elf_gc_mark_hook_fn gc_mark_hook
;
495 htab
= elf_hash_table (info
);
496 hdr_info
= &htab
->eh_info
;
497 if (hdr_info
->parsed_eh_frames
)
501 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
503 /* This file does not contain .eh_frame information. */
507 if (bfd_is_abs_section (sec
->output_section
))
509 /* At least one of the sections is being discarded from the
510 link, so we should just ignore them. */
514 /* Read the frame unwind information from abfd. */
516 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
519 && bfd_get_32 (abfd
, ehbuf
) == 0
520 && cookie
->rel
== cookie
->relend
)
522 /* Empty .eh_frame section. */
527 /* If .eh_frame section size doesn't fit into int, we cannot handle
528 it (it would need to use 64-bit .eh_frame format anyway). */
529 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
531 ptr_size
= (get_elf_backend_data (abfd
)
532 ->elf_backend_eh_frame_address_size (abfd
, sec
));
533 REQUIRE (ptr_size
!= 0);
535 /* Go through the section contents and work out how many FDEs and
538 end
= ehbuf
+ sec
->size
;
545 /* Read the length of the entry. */
546 REQUIRE (skip_bytes (&buf
, end
, 4));
547 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
549 /* 64-bit .eh_frame is not supported. */
550 REQUIRE (hdr_length
!= 0xffffffff);
554 REQUIRE (skip_bytes (&buf
, end
, 4));
555 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
559 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
562 sec_info
= (struct eh_frame_sec_info
*)
563 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
564 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
567 /* We need to have a "struct cie" for each CIE in this section. */
568 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
569 REQUIRE (local_cies
);
571 /* FIXME: octets_per_byte. */
572 #define ENSURE_NO_RELOCS(buf) \
573 REQUIRE (!(cookie->rel < cookie->relend \
574 && (cookie->rel->r_offset \
575 < (bfd_size_type) ((buf) - ehbuf)) \
576 && cookie->rel->r_info != 0))
578 /* FIXME: octets_per_byte. */
579 #define SKIP_RELOCS(buf) \
580 while (cookie->rel < cookie->relend \
581 && (cookie->rel->r_offset \
582 < (bfd_size_type) ((buf) - ehbuf))) \
585 /* FIXME: octets_per_byte. */
586 #define GET_RELOC(buf) \
587 ((cookie->rel < cookie->relend \
588 && (cookie->rel->r_offset \
589 == (bfd_size_type) ((buf) - ehbuf))) \
590 ? cookie->rel : NULL)
594 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
595 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
598 bfd_byte
*start
, *insns
, *insns_end
;
599 bfd_size_type length
;
600 unsigned int set_loc_count
;
602 this_inf
= sec_info
->entry
+ sec_info
->count
;
605 /* Read the length of the entry. */
606 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
607 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
609 /* The CIE/FDE must be fully contained in this input section. */
610 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
611 end
= buf
+ hdr_length
;
613 this_inf
->offset
= last_fde
- ehbuf
;
614 this_inf
->size
= 4 + hdr_length
;
615 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
619 /* A zero-length CIE should only be found at the end of
621 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
622 ENSURE_NO_RELOCS (buf
);
627 REQUIRE (skip_bytes (&buf
, end
, 4));
628 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
632 unsigned int initial_insn_length
;
637 /* Point CIE to one of the section-local cie structures. */
638 cie
= local_cies
+ cie_count
++;
640 cie
->cie_inf
= this_inf
;
641 cie
->length
= hdr_length
;
642 cie
->output_sec
= sec
->output_section
;
644 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
646 /* Cannot handle unknown versions. */
647 REQUIRE (cie
->version
== 1
649 || cie
->version
== 4);
650 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
652 strcpy (cie
->augmentation
, (char *) buf
);
653 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
654 ENSURE_NO_RELOCS (buf
);
655 if (buf
[0] == 'e' && buf
[1] == 'h')
657 /* GCC < 3.0 .eh_frame CIE */
658 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
659 is private to each CIE, so we don't need it for anything.
661 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
664 if (cie
->version
>= 4)
666 REQUIRE (buf
+ 1 < end
);
667 REQUIRE (buf
[0] == ptr_size
);
668 REQUIRE (buf
[1] == 0);
671 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
672 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
673 if (cie
->version
== 1)
676 cie
->ra_column
= *buf
++;
679 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
680 ENSURE_NO_RELOCS (buf
);
681 cie
->lsda_encoding
= DW_EH_PE_omit
;
682 cie
->fde_encoding
= DW_EH_PE_omit
;
683 cie
->per_encoding
= DW_EH_PE_omit
;
684 aug
= cie
->augmentation
;
685 if (aug
[0] != 'e' || aug
[1] != 'h')
690 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
691 ENSURE_NO_RELOCS (buf
);
698 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
699 ENSURE_NO_RELOCS (buf
);
700 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
703 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
704 ENSURE_NO_RELOCS (buf
);
705 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
713 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
714 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
717 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
719 length
= -(buf
- ehbuf
) & (per_width
- 1);
720 REQUIRE (skip_bytes (&buf
, end
, length
));
722 this_inf
->u
.cie
.personality_offset
= buf
- start
;
723 ENSURE_NO_RELOCS (buf
);
724 /* Ensure we have a reloc here. */
725 REQUIRE (GET_RELOC (buf
));
726 cie
->personality
.reloc_index
727 = cookie
->rel
- cookie
->rels
;
728 /* Cope with MIPS-style composite relocations. */
731 while (GET_RELOC (buf
) != NULL
);
732 REQUIRE (skip_bytes (&buf
, end
, per_width
));
736 /* Unrecognized augmentation. Better bail out. */
741 /* For shared libraries, try to get rid of as many RELATIVE relocs
744 && (get_elf_backend_data (abfd
)
745 ->elf_backend_can_make_relative_eh_frame
748 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
749 this_inf
->make_relative
= 1;
750 /* If the CIE doesn't already have an 'R' entry, it's fairly
751 easy to add one, provided that there's no aligned data
752 after the augmentation string. */
753 else if (cie
->fde_encoding
== DW_EH_PE_omit
754 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
756 if (*cie
->augmentation
== 0)
757 this_inf
->add_augmentation_size
= 1;
758 this_inf
->u
.cie
.add_fde_encoding
= 1;
759 this_inf
->make_relative
= 1;
762 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
763 cie
->can_make_lsda_relative
= 1;
766 /* If FDE encoding was not specified, it defaults to
768 if (cie
->fde_encoding
== DW_EH_PE_omit
)
769 cie
->fde_encoding
= DW_EH_PE_absptr
;
771 initial_insn_length
= end
- buf
;
772 cie
->initial_insn_length
= initial_insn_length
;
773 memcpy (cie
->initial_instructions
, buf
,
774 initial_insn_length
<= sizeof (cie
->initial_instructions
)
775 ? initial_insn_length
: sizeof (cie
->initial_instructions
));
777 buf
+= initial_insn_length
;
778 ENSURE_NO_RELOCS (buf
);
780 if (hdr_info
->merge_cies
)
781 this_inf
->u
.cie
.u
.full_cie
= cie
;
782 this_inf
->u
.cie
.per_encoding_relative
783 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
787 /* Find the corresponding CIE. */
788 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
789 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
790 if (cie_offset
== cie
->cie_inf
->offset
)
793 /* Ensure this FDE references one of the CIEs in this input
795 REQUIRE (cie
!= local_cies
+ cie_count
);
796 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
797 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
798 this_inf
->add_augmentation_size
799 = cie
->cie_inf
->add_augmentation_size
;
801 ENSURE_NO_RELOCS (buf
);
802 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
806 REQUIRE (GET_RELOC (buf
));
808 /* Chain together the FDEs for each section. */
809 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
810 /* RSEC will be NULL if FDE was cleared out as it was belonging to
811 a discarded SHT_GROUP. */
814 REQUIRE (rsec
->owner
== abfd
);
815 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
816 elf_fde_list (rsec
) = this_inf
;
820 /* Skip the initial location and address range. */
822 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
823 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
825 /* Skip the augmentation size, if present. */
826 if (cie
->augmentation
[0] == 'z')
827 REQUIRE (read_uleb128 (&buf
, end
, &length
));
831 /* Of the supported augmentation characters above, only 'L'
832 adds augmentation data to the FDE. This code would need to
833 be adjusted if any future augmentations do the same thing. */
834 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
837 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
838 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
839 this_inf
->lsda_offset
= buf
- start
;
840 /* If there's no 'z' augmentation, we don't know where the
841 CFA insns begin. Assume no padding. */
842 if (cie
->augmentation
[0] != 'z')
846 /* Skip over the augmentation data. */
847 REQUIRE (skip_bytes (&buf
, end
, length
));
850 buf
= last_fde
+ 4 + hdr_length
;
852 /* For NULL RSEC (cleared FDE belonging to a discarded section)
853 the relocations are commonly cleared. We do not sanity check if
854 all these relocations are cleared as (1) relocations to
855 .gcc_except_table will remain uncleared (they will get dropped
856 with the drop of this unused FDE) and (2) BFD already safely drops
857 relocations of any type to .eh_frame by
858 elf_section_ignore_discarded_relocs.
859 TODO: The .gcc_except_table entries should be also filtered as
860 .eh_frame entries; or GCC could rather use COMDAT for them. */
864 /* Try to interpret the CFA instructions and find the first
865 padding nop. Shrink this_inf's size so that it doesn't
866 include the padding. */
867 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
869 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
870 /* If we don't understand the CFA instructions, we can't know
871 what needs to be adjusted there. */
872 if (insns_end
== NULL
873 /* For the time being we don't support DW_CFA_set_loc in
875 || (set_loc_count
&& this_inf
->cie
))
877 this_inf
->size
-= end
- insns_end
;
878 if (insns_end
!= end
&& this_inf
->cie
)
880 cie
->initial_insn_length
-= end
- insns_end
;
881 cie
->length
-= end
- insns_end
;
884 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
885 || this_inf
->make_relative
))
890 this_inf
->set_loc
= (unsigned int *)
891 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
892 REQUIRE (this_inf
->set_loc
);
893 this_inf
->set_loc
[0] = set_loc_count
;
898 if (*p
== DW_CFA_set_loc
)
899 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
900 REQUIRE (skip_cfa_op (&p
, end
, length
));
904 this_inf
->removed
= 1;
905 this_inf
->fde_encoding
= cie
->fde_encoding
;
906 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
909 BFD_ASSERT (sec_info
->count
== num_entries
);
910 BFD_ASSERT (cie_count
== num_cies
);
912 elf_section_data (sec
)->sec_info
= sec_info
;
913 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
914 if (hdr_info
->merge_cies
)
916 sec_info
->cies
= local_cies
;
922 (*info
->callbacks
->einfo
)
923 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
925 hdr_info
->table
= FALSE
;
936 /* Finish a pass over all .eh_frame sections. */
939 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
941 struct eh_frame_hdr_info
*hdr_info
;
943 hdr_info
= &elf_hash_table (info
)->eh_info
;
944 hdr_info
->parsed_eh_frames
= TRUE
;
947 /* Mark all relocations against CIE or FDE ENT, which occurs in
948 .eh_frame section SEC. COOKIE describes the relocations in SEC;
949 its "rel" field can be changed freely. */
952 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
953 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
954 struct elf_reloc_cookie
*cookie
)
956 /* FIXME: octets_per_byte. */
957 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
958 cookie
->rel
< cookie
->relend
959 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
961 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
967 /* Mark all the relocations against FDEs that relate to code in input
968 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
969 relocations are described by COOKIE. */
972 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
973 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
974 struct elf_reloc_cookie
*cookie
)
976 struct eh_cie_fde
*fde
, *cie
;
978 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
980 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
983 /* At this stage, all cie_inf fields point to local CIEs, so we
984 can use the same cookie to refer to them. */
985 cie
= fde
->u
.fde
.cie_inf
;
986 if (!cie
->u
.cie
.gc_mark
)
988 cie
->u
.cie
.gc_mark
= 1;
989 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
996 /* Input section SEC of ABFD is an .eh_frame section that contains the
997 CIE described by CIE_INF. Return a version of CIE_INF that is going
998 to be kept in the output, adding CIE_INF to the output if necessary.
1000 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1001 relocations in REL. */
1003 static struct eh_cie_fde
*
1004 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1005 struct eh_frame_hdr_info
*hdr_info
,
1006 struct elf_reloc_cookie
*cookie
,
1007 struct eh_cie_fde
*cie_inf
)
1009 unsigned long r_symndx
;
1010 struct cie
*cie
, *new_cie
;
1011 Elf_Internal_Rela
*rel
;
1014 /* Use CIE_INF if we have already decided to keep it. */
1015 if (!cie_inf
->removed
)
1018 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1019 if (cie_inf
->u
.cie
.merged
)
1020 return cie_inf
->u
.cie
.u
.merged_with
;
1022 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1024 /* Assume we will need to keep CIE_INF. */
1025 cie_inf
->removed
= 0;
1026 cie_inf
->u
.cie
.u
.sec
= sec
;
1028 /* If we are not merging CIEs, use CIE_INF. */
1032 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1034 bfd_boolean per_binds_local
;
1036 /* Work out the address of personality routine, or at least
1037 enough info that we could calculate the address had we made a
1038 final section layout. The symbol on the reloc is enough,
1039 either the hash for a global, or (bfd id, index) pair for a
1040 local. The assumption here is that no one uses addends on
1042 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1043 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1045 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1046 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1049 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1050 if (r_symndx
>= cookie
->locsymcount
1051 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1053 struct elf_link_hash_entry
*h
;
1055 r_symndx
-= cookie
->extsymoff
;
1056 h
= cookie
->sym_hashes
[r_symndx
];
1058 while (h
->root
.type
== bfd_link_hash_indirect
1059 || h
->root
.type
== bfd_link_hash_warning
)
1060 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1062 cie
->personality
.h
= h
;
1063 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1067 Elf_Internal_Sym
*sym
;
1070 sym
= &cookie
->locsyms
[r_symndx
];
1071 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1072 if (sym_sec
== NULL
)
1075 if (sym_sec
->kept_section
!= NULL
)
1076 sym_sec
= sym_sec
->kept_section
;
1077 if (sym_sec
->output_section
== NULL
)
1080 cie
->local_personality
= 1;
1081 cie
->personality
.sym
.bfd_id
= abfd
->id
;
1082 cie
->personality
.sym
.index
= r_symndx
;
1083 per_binds_local
= TRUE
;
1088 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1089 && (get_elf_backend_data (abfd
)
1090 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1092 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1093 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1097 /* See if we can merge this CIE with an earlier one. */
1098 cie
->output_sec
= sec
->output_section
;
1099 cie_compute_hash (cie
);
1100 if (hdr_info
->cies
== NULL
)
1102 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1103 if (hdr_info
->cies
== NULL
)
1106 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
, cie
->hash
, INSERT
);
1110 new_cie
= (struct cie
*) *loc
;
1111 if (new_cie
== NULL
)
1113 /* Keep CIE_INF and record it in the hash table. */
1114 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1115 if (new_cie
== NULL
)
1118 memcpy (new_cie
, cie
, sizeof (struct cie
));
1123 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1124 cie_inf
->removed
= 1;
1125 cie_inf
->u
.cie
.merged
= 1;
1126 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1127 if (cie_inf
->u
.cie
.make_lsda_relative
)
1128 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1130 return new_cie
->cie_inf
;
1133 /* This function is called for each input file before the .eh_frame
1134 section is relocated. It discards duplicate CIEs and FDEs for discarded
1135 functions. The function returns TRUE iff any entries have been
1139 _bfd_elf_discard_section_eh_frame
1140 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1141 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1142 struct elf_reloc_cookie
*cookie
)
1144 struct eh_cie_fde
*ent
;
1145 struct eh_frame_sec_info
*sec_info
;
1146 struct eh_frame_hdr_info
*hdr_info
;
1147 unsigned int ptr_size
, offset
;
1149 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1152 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1153 if (sec_info
== NULL
)
1156 ptr_size
= (get_elf_backend_data (sec
->owner
)
1157 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1159 hdr_info
= &elf_hash_table (info
)->eh_info
;
1160 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1162 /* There should only be one zero terminator, on the last input
1163 file supplying .eh_frame (crtend.o). Remove any others. */
1164 ent
->removed
= sec
->map_head
.s
!= NULL
;
1168 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1171 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1173 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1174 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1179 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1180 /* FIXME: octets_per_byte. */
1181 BFD_ASSERT (cookie
->rel
< cookie
->relend
1182 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1183 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1188 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1189 && ent
->make_relative
== 0)
1190 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1192 /* If a shared library uses absolute pointers
1193 which we cannot turn into PC relative,
1194 don't create the binary search table,
1195 since it is affected by runtime relocations. */
1196 hdr_info
->table
= FALSE
;
1197 (*info
->callbacks
->einfo
)
1198 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1199 " table being created.\n"), abfd
, sec
);
1202 hdr_info
->fde_count
++;
1203 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1204 cookie
, ent
->u
.fde
.cie_inf
);
1210 free (sec_info
->cies
);
1211 sec_info
->cies
= NULL
;
1215 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1218 ent
->new_offset
= offset
;
1219 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1222 sec
->rawsize
= sec
->size
;
1224 return offset
!= sec
->rawsize
;
1227 /* This function is called for .eh_frame_hdr section after
1228 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1229 input sections. It finalizes the size of .eh_frame_hdr section. */
1232 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1234 struct elf_link_hash_table
*htab
;
1235 struct eh_frame_hdr_info
*hdr_info
;
1238 htab
= elf_hash_table (info
);
1239 hdr_info
= &htab
->eh_info
;
1241 if (hdr_info
->cies
!= NULL
)
1243 htab_delete (hdr_info
->cies
);
1244 hdr_info
->cies
= NULL
;
1247 sec
= hdr_info
->hdr_sec
;
1251 sec
->size
= EH_FRAME_HDR_SIZE
;
1252 if (hdr_info
->table
)
1253 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1255 elf_eh_frame_hdr (abfd
) = sec
;
1259 /* Return true if there is at least one non-empty .eh_frame section in
1260 input files. Can only be called after ld has mapped input to
1261 output sections, and before sections are stripped. */
1263 _bfd_elf_eh_frame_present (struct bfd_link_info
*info
)
1265 asection
*eh
= bfd_get_section_by_name (info
->output_bfd
, ".eh_frame");
1270 /* Count only sections which have at least a single CIE or FDE.
1271 There cannot be any CIE or FDE <= 8 bytes. */
1272 for (eh
= eh
->map_head
.s
; eh
!= NULL
; eh
= eh
->map_head
.s
)
1279 /* This function is called from size_dynamic_sections.
1280 It needs to decide whether .eh_frame_hdr should be output or not,
1281 because when the dynamic symbol table has been sized it is too late
1282 to strip sections. */
1285 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1287 struct elf_link_hash_table
*htab
;
1288 struct eh_frame_hdr_info
*hdr_info
;
1290 htab
= elf_hash_table (info
);
1291 hdr_info
= &htab
->eh_info
;
1292 if (hdr_info
->hdr_sec
== NULL
)
1295 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
)
1296 || !info
->eh_frame_hdr
1297 || !_bfd_elf_eh_frame_present (info
))
1299 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1300 hdr_info
->hdr_sec
= NULL
;
1304 hdr_info
->table
= TRUE
;
1308 /* Adjust an address in the .eh_frame section. Given OFFSET within
1309 SEC, this returns the new offset in the adjusted .eh_frame section,
1310 or -1 if the address refers to a CIE/FDE which has been removed
1311 or to offset with dynamic relocation which is no longer needed. */
1314 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1315 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1319 struct eh_frame_sec_info
*sec_info
;
1320 unsigned int lo
, hi
, mid
;
1322 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1324 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1326 if (offset
>= sec
->rawsize
)
1327 return offset
- sec
->rawsize
+ sec
->size
;
1330 hi
= sec_info
->count
;
1334 mid
= (lo
+ hi
) / 2;
1335 if (offset
< sec_info
->entry
[mid
].offset
)
1338 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1344 BFD_ASSERT (lo
< hi
);
1346 /* FDE or CIE was removed. */
1347 if (sec_info
->entry
[mid
].removed
)
1348 return (bfd_vma
) -1;
1350 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1351 no need for run-time relocation against the personality field. */
1352 if (sec_info
->entry
[mid
].cie
1353 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1354 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1355 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1356 return (bfd_vma
) -2;
1358 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1359 relocation against FDE's initial_location field. */
1360 if (!sec_info
->entry
[mid
].cie
1361 && sec_info
->entry
[mid
].make_relative
1362 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1363 return (bfd_vma
) -2;
1365 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1366 for run-time relocation against LSDA field. */
1367 if (!sec_info
->entry
[mid
].cie
1368 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1369 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1370 + sec_info
->entry
[mid
].lsda_offset
))
1371 return (bfd_vma
) -2;
1373 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1374 relocation against DW_CFA_set_loc's arguments. */
1375 if (sec_info
->entry
[mid
].set_loc
1376 && sec_info
->entry
[mid
].make_relative
1377 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1378 + sec_info
->entry
[mid
].set_loc
[1]))
1382 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1383 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1384 + sec_info
->entry
[mid
].set_loc
[cnt
])
1385 return (bfd_vma
) -2;
1388 /* Any new augmentation bytes go before the first relocation. */
1389 return (offset
+ sec_info
->entry
[mid
].new_offset
1390 - sec_info
->entry
[mid
].offset
1391 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1392 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1395 /* Write out .eh_frame section. This is called with the relocated
1399 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1400 struct bfd_link_info
*info
,
1404 struct eh_frame_sec_info
*sec_info
;
1405 struct elf_link_hash_table
*htab
;
1406 struct eh_frame_hdr_info
*hdr_info
;
1407 unsigned int ptr_size
;
1408 struct eh_cie_fde
*ent
;
1410 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1411 /* FIXME: octets_per_byte. */
1412 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1413 sec
->output_offset
, sec
->size
);
1415 ptr_size
= (get_elf_backend_data (abfd
)
1416 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1417 BFD_ASSERT (ptr_size
!= 0);
1419 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1420 htab
= elf_hash_table (info
);
1421 hdr_info
= &htab
->eh_info
;
1423 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1424 hdr_info
->array
= (struct eh_frame_array_ent
*)
1425 bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1426 if (hdr_info
->array
== NULL
)
1429 /* The new offsets can be bigger or smaller than the original offsets.
1430 We therefore need to make two passes over the section: one backward
1431 pass to move entries up and one forward pass to move entries down.
1432 The two passes won't interfere with each other because entries are
1434 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1435 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1436 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1438 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1439 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1440 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1442 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1444 unsigned char *buf
, *end
;
1445 unsigned int new_size
;
1452 /* Any terminating FDE must be at the end of the section. */
1453 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1457 buf
= contents
+ ent
->new_offset
;
1458 end
= buf
+ ent
->size
;
1459 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1461 /* Update the size. It may be shrinked. */
1462 bfd_put_32 (abfd
, new_size
- 4, buf
);
1464 /* Filling the extra bytes with DW_CFA_nops. */
1465 if (new_size
!= ent
->size
)
1466 memset (end
, 0, new_size
- ent
->size
);
1471 if (ent
->make_relative
1472 || ent
->u
.cie
.make_lsda_relative
1473 || ent
->u
.cie
.per_encoding_relative
)
1476 unsigned int action
, extra_string
, extra_data
;
1477 unsigned int per_width
, per_encoding
;
1479 /* Need to find 'R' or 'L' augmentation's argument and modify
1480 DW_EH_PE_* value. */
1481 action
= ((ent
->make_relative
? 1 : 0)
1482 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1483 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1484 extra_string
= extra_augmentation_string_bytes (ent
);
1485 extra_data
= extra_augmentation_data_bytes (ent
);
1487 /* Skip length, id and version. */
1490 buf
+= strlen (aug
) + 1;
1491 skip_leb128 (&buf
, end
);
1492 skip_leb128 (&buf
, end
);
1493 skip_leb128 (&buf
, end
);
1496 /* The uleb128 will always be a single byte for the kind
1497 of augmentation strings that we're prepared to handle. */
1498 *buf
++ += extra_data
;
1502 /* Make room for the new augmentation string and data bytes. */
1503 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1504 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1505 buf
+= extra_string
;
1506 end
+= extra_string
+ extra_data
;
1508 if (ent
->add_augmentation_size
)
1511 *buf
++ = extra_data
- 1;
1513 if (ent
->u
.cie
.add_fde_encoding
)
1515 BFD_ASSERT (action
& 1);
1517 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
1527 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1528 *buf
= make_pc_relative (*buf
, ptr_size
);
1534 if (ent
->u
.cie
.make_per_encoding_relative
)
1535 *buf
= make_pc_relative (*buf
, ptr_size
);
1536 per_encoding
= *buf
++;
1537 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1538 BFD_ASSERT (per_width
!= 0);
1539 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1540 == ent
->u
.cie
.per_encoding_relative
);
1541 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
1543 + ((buf
- contents
+ per_width
- 1)
1544 & ~((bfd_size_type
) per_width
- 1)));
1549 val
= read_value (abfd
, buf
, per_width
,
1550 get_DW_EH_PE_signed (per_encoding
));
1551 if (ent
->u
.cie
.make_per_encoding_relative
)
1552 val
-= (sec
->output_section
->vma
1553 + sec
->output_offset
1554 + (buf
- contents
));
1557 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1558 val
-= extra_string
+ extra_data
;
1560 write_value (abfd
, buf
, val
, per_width
);
1568 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1569 *buf
= make_pc_relative (*buf
, ptr_size
);
1584 bfd_vma value
, address
;
1587 struct eh_cie_fde
*cie
;
1590 cie
= ent
->u
.fde
.cie_inf
;
1592 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1593 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1594 bfd_put_32 (abfd
, value
, buf
);
1596 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1597 value
= read_value (abfd
, buf
, width
,
1598 get_DW_EH_PE_signed (ent
->fde_encoding
));
1602 switch (ent
->fde_encoding
& 0x70)
1604 case DW_EH_PE_textrel
:
1605 BFD_ASSERT (hdr_info
== NULL
);
1607 case DW_EH_PE_datarel
:
1609 switch (abfd
->arch_info
->arch
)
1612 BFD_ASSERT (elf_gp (abfd
) != 0);
1613 address
+= elf_gp (abfd
);
1616 (*info
->callbacks
->einfo
)
1617 (_("%P: DW_EH_PE_datarel unspecified"
1618 " for this architecture.\n"));
1622 BFD_ASSERT (htab
->hgot
!= NULL
1623 && ((htab
->hgot
->root
.type
1624 == bfd_link_hash_defined
)
1625 || (htab
->hgot
->root
.type
1626 == bfd_link_hash_defweak
)));
1628 += (htab
->hgot
->root
.u
.def
.value
1629 + htab
->hgot
->root
.u
.def
.section
->output_offset
1630 + (htab
->hgot
->root
.u
.def
.section
->output_section
1636 case DW_EH_PE_pcrel
:
1637 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1638 address
+= (sec
->output_section
->vma
1639 + sec
->output_offset
1643 if (ent
->make_relative
)
1644 value
-= (sec
->output_section
->vma
1645 + sec
->output_offset
1646 + ent
->new_offset
+ 8);
1647 write_value (abfd
, buf
, value
, width
);
1654 /* The address calculation may overflow, giving us a
1655 value greater than 4G on a 32-bit target when
1656 dwarf_vma is 64-bit. */
1657 if (sizeof (address
) > 4 && ptr_size
== 4)
1658 address
&= 0xffffffff;
1659 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1660 hdr_info
->array
[hdr_info
->array_count
++].fde
1661 = (sec
->output_section
->vma
1662 + sec
->output_offset
1666 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
1667 || cie
->u
.cie
.make_lsda_relative
)
1669 buf
+= ent
->lsda_offset
;
1670 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1671 value
= read_value (abfd
, buf
, width
,
1672 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1675 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1676 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1677 else if (cie
->u
.cie
.make_lsda_relative
)
1678 value
-= (sec
->output_section
->vma
1679 + sec
->output_offset
1680 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1681 write_value (abfd
, buf
, value
, width
);
1684 else if (ent
->add_augmentation_size
)
1686 /* Skip the PC and length and insert a zero byte for the
1687 augmentation size. */
1689 memmove (buf
+ 1, buf
, end
- buf
);
1695 /* Adjust DW_CFA_set_loc. */
1699 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1700 new_offset
= ent
->new_offset
+ 8
1701 + extra_augmentation_string_bytes (ent
)
1702 + extra_augmentation_data_bytes (ent
);
1704 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1706 buf
= start
+ ent
->set_loc
[cnt
];
1708 value
= read_value (abfd
, buf
, width
,
1709 get_DW_EH_PE_signed (ent
->fde_encoding
));
1713 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
1714 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
1715 if (ent
->make_relative
)
1716 value
-= (sec
->output_section
->vma
1717 + sec
->output_offset
1718 + new_offset
+ ent
->set_loc
[cnt
]);
1719 write_value (abfd
, buf
, value
, width
);
1725 /* We don't align the section to its section alignment since the
1726 runtime library only expects all CIE/FDE records aligned at
1727 the pointer size. _bfd_elf_discard_section_eh_frame should
1728 have padded CIE/FDE records to multiple of pointer size with
1729 size_of_output_cie_fde. */
1730 if ((sec
->size
% ptr_size
) != 0)
1733 /* FIXME: octets_per_byte. */
1734 return bfd_set_section_contents (abfd
, sec
->output_section
,
1735 contents
, (file_ptr
) sec
->output_offset
,
1739 /* Helper function used to sort .eh_frame_hdr search table by increasing
1740 VMA of FDE initial location. */
1743 vma_compare (const void *a
, const void *b
)
1745 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
1746 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
1747 if (p
->initial_loc
> q
->initial_loc
)
1749 if (p
->initial_loc
< q
->initial_loc
)
1754 /* Write out .eh_frame_hdr section. This must be called after
1755 _bfd_elf_write_section_eh_frame has been called on all input
1757 .eh_frame_hdr format:
1758 ubyte version (currently 1)
1759 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1761 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1762 number (or DW_EH_PE_omit if there is no
1763 binary search table computed))
1764 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1765 or DW_EH_PE_omit if not present.
1766 DW_EH_PE_datarel is using address of
1767 .eh_frame_hdr section start as base)
1768 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1769 optionally followed by:
1770 [encoded] fde_count (total number of FDEs in .eh_frame section)
1771 fde_count x [encoded] initial_loc, fde
1772 (array of encoded pairs containing
1773 FDE initial_location field and FDE address,
1774 sorted by increasing initial_loc). */
1777 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1779 struct elf_link_hash_table
*htab
;
1780 struct eh_frame_hdr_info
*hdr_info
;
1782 bfd_boolean retval
= TRUE
;
1784 htab
= elf_hash_table (info
);
1785 hdr_info
= &htab
->eh_info
;
1786 sec
= hdr_info
->hdr_sec
;
1788 if (info
->eh_frame_hdr
&& sec
!= NULL
)
1791 asection
*eh_frame_sec
;
1793 bfd_vma encoded_eh_frame
;
1795 size
= EH_FRAME_HDR_SIZE
;
1796 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1797 size
+= 4 + hdr_info
->fde_count
* 8;
1798 contents
= (bfd_byte
*) bfd_malloc (size
);
1799 if (contents
== NULL
)
1802 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1803 if (eh_frame_sec
== NULL
)
1809 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1812 /* .eh_frame offset. */
1813 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1814 (abfd
, info
, eh_frame_sec
, 0, sec
, 4, &encoded_eh_frame
);
1816 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1818 /* FDE count encoding. */
1819 contents
[2] = DW_EH_PE_udata4
;
1820 /* Search table encoding. */
1821 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
1825 contents
[2] = DW_EH_PE_omit
;
1826 contents
[3] = DW_EH_PE_omit
;
1828 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1830 if (contents
[2] != DW_EH_PE_omit
)
1834 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1835 qsort (hdr_info
->array
, hdr_info
->fde_count
,
1836 sizeof (*hdr_info
->array
), vma_compare
);
1837 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1840 hdr_info
->array
[i
].initial_loc
1841 - sec
->output_section
->vma
,
1842 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1844 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1845 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1849 /* FIXME: octets_per_byte. */
1850 retval
= bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1851 (file_ptr
) sec
->output_offset
,
1855 if (hdr_info
->array
!= NULL
)
1856 free (hdr_info
->array
);
1860 /* Return the width of FDE addresses. This is the default implementation. */
1863 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1865 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1868 /* Decide whether we can use a PC-relative encoding within the given
1869 EH frame section. This is the default implementation. */
1872 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1873 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1874 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1879 /* Select an encoding for the given address. Preference is given to
1880 PC-relative addressing modes. */
1883 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1884 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1885 asection
*osec
, bfd_vma offset
,
1886 asection
*loc_sec
, bfd_vma loc_offset
,
1889 *encoded
= osec
->vma
+ offset
-
1890 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1891 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;