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 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
456 information in the section's sec_info field on success. COOKIE
457 describes the relocations in SEC. */
460 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
461 asection
*sec
, struct elf_reloc_cookie
*cookie
)
463 #define REQUIRE(COND) \
466 goto free_no_table; \
469 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
471 struct eh_cie_fde
*this_inf
;
472 unsigned int hdr_length
, hdr_id
;
473 unsigned int cie_count
;
474 struct cie
*cie
, *local_cies
= NULL
;
475 struct elf_link_hash_table
*htab
;
476 struct eh_frame_hdr_info
*hdr_info
;
477 struct eh_frame_sec_info
*sec_info
= NULL
;
478 unsigned int ptr_size
;
479 unsigned int num_cies
;
480 unsigned int num_entries
;
481 elf_gc_mark_hook_fn gc_mark_hook
;
483 htab
= elf_hash_table (info
);
484 hdr_info
= &htab
->eh_info
;
487 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
489 /* This file does not contain .eh_frame information. */
493 if (bfd_is_abs_section (sec
->output_section
))
495 /* At least one of the sections is being discarded from the
496 link, so we should just ignore them. */
500 /* Read the frame unwind information from abfd. */
502 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
505 && bfd_get_32 (abfd
, ehbuf
) == 0
506 && cookie
->rel
== cookie
->relend
)
508 /* Empty .eh_frame section. */
513 /* If .eh_frame section size doesn't fit into int, we cannot handle
514 it (it would need to use 64-bit .eh_frame format anyway). */
515 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
517 ptr_size
= (get_elf_backend_data (abfd
)
518 ->elf_backend_eh_frame_address_size (abfd
, sec
));
519 REQUIRE (ptr_size
!= 0);
521 /* Go through the section contents and work out how many FDEs and
524 end
= ehbuf
+ sec
->size
;
531 /* Read the length of the entry. */
532 REQUIRE (skip_bytes (&buf
, end
, 4));
533 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
535 /* 64-bit .eh_frame is not supported. */
536 REQUIRE (hdr_length
!= 0xffffffff);
540 REQUIRE (skip_bytes (&buf
, end
, 4));
541 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
545 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
548 sec_info
= (struct eh_frame_sec_info
*)
549 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
550 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
553 /* We need to have a "struct cie" for each CIE in this section. */
554 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
555 REQUIRE (local_cies
);
557 /* FIXME: octets_per_byte. */
558 #define ENSURE_NO_RELOCS(buf) \
559 REQUIRE (!(cookie->rel < cookie->relend \
560 && (cookie->rel->r_offset \
561 < (bfd_size_type) ((buf) - ehbuf)) \
562 && cookie->rel->r_info != 0))
564 /* FIXME: octets_per_byte. */
565 #define SKIP_RELOCS(buf) \
566 while (cookie->rel < cookie->relend \
567 && (cookie->rel->r_offset \
568 < (bfd_size_type) ((buf) - ehbuf))) \
571 /* FIXME: octets_per_byte. */
572 #define GET_RELOC(buf) \
573 ((cookie->rel < cookie->relend \
574 && (cookie->rel->r_offset \
575 == (bfd_size_type) ((buf) - ehbuf))) \
576 ? cookie->rel : NULL)
580 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
581 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
584 bfd_byte
*start
, *insns
, *insns_end
;
585 bfd_size_type length
;
586 unsigned int set_loc_count
;
588 this_inf
= sec_info
->entry
+ sec_info
->count
;
591 /* Read the length of the entry. */
592 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
593 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
595 /* The CIE/FDE must be fully contained in this input section. */
596 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
597 end
= buf
+ hdr_length
;
599 this_inf
->offset
= last_fde
- ehbuf
;
600 this_inf
->size
= 4 + hdr_length
;
601 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
605 /* A zero-length CIE should only be found at the end of
607 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
608 ENSURE_NO_RELOCS (buf
);
613 REQUIRE (skip_bytes (&buf
, end
, 4));
614 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
618 unsigned int initial_insn_length
;
623 /* Point CIE to one of the section-local cie structures. */
624 cie
= local_cies
+ cie_count
++;
626 cie
->cie_inf
= this_inf
;
627 cie
->length
= hdr_length
;
628 cie
->output_sec
= sec
->output_section
;
630 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
632 /* Cannot handle unknown versions. */
633 REQUIRE (cie
->version
== 1
635 || cie
->version
== 4);
636 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
638 strcpy (cie
->augmentation
, (char *) buf
);
639 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
640 ENSURE_NO_RELOCS (buf
);
641 if (buf
[0] == 'e' && buf
[1] == 'h')
643 /* GCC < 3.0 .eh_frame CIE */
644 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
645 is private to each CIE, so we don't need it for anything.
647 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
650 if (cie
->version
>= 4)
652 REQUIRE (buf
+ 1 < end
);
653 REQUIRE (buf
[0] == ptr_size
);
654 REQUIRE (buf
[1] == 0);
657 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
658 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
659 if (cie
->version
== 1)
662 cie
->ra_column
= *buf
++;
665 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
666 ENSURE_NO_RELOCS (buf
);
667 cie
->lsda_encoding
= DW_EH_PE_omit
;
668 cie
->fde_encoding
= DW_EH_PE_omit
;
669 cie
->per_encoding
= DW_EH_PE_omit
;
670 aug
= cie
->augmentation
;
671 if (aug
[0] != 'e' || aug
[1] != 'h')
676 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
677 ENSURE_NO_RELOCS (buf
);
684 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
685 ENSURE_NO_RELOCS (buf
);
686 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
689 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
690 ENSURE_NO_RELOCS (buf
);
691 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
699 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
700 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
703 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
705 length
= -(buf
- ehbuf
) & (per_width
- 1);
706 REQUIRE (skip_bytes (&buf
, end
, length
));
708 this_inf
->u
.cie
.personality_offset
= buf
- start
;
709 ENSURE_NO_RELOCS (buf
);
710 /* Ensure we have a reloc here. */
711 REQUIRE (GET_RELOC (buf
));
712 cie
->personality
.reloc_index
713 = cookie
->rel
- cookie
->rels
;
714 /* Cope with MIPS-style composite relocations. */
717 while (GET_RELOC (buf
) != NULL
);
718 REQUIRE (skip_bytes (&buf
, end
, per_width
));
722 /* Unrecognized augmentation. Better bail out. */
727 /* For shared libraries, try to get rid of as many RELATIVE relocs
730 && (get_elf_backend_data (abfd
)
731 ->elf_backend_can_make_relative_eh_frame
734 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
735 this_inf
->make_relative
= 1;
736 /* If the CIE doesn't already have an 'R' entry, it's fairly
737 easy to add one, provided that there's no aligned data
738 after the augmentation string. */
739 else if (cie
->fde_encoding
== DW_EH_PE_omit
740 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
742 if (*cie
->augmentation
== 0)
743 this_inf
->add_augmentation_size
= 1;
744 this_inf
->u
.cie
.add_fde_encoding
= 1;
745 this_inf
->make_relative
= 1;
748 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
749 cie
->can_make_lsda_relative
= 1;
752 /* If FDE encoding was not specified, it defaults to
754 if (cie
->fde_encoding
== DW_EH_PE_omit
)
755 cie
->fde_encoding
= DW_EH_PE_absptr
;
757 initial_insn_length
= end
- buf
;
758 cie
->initial_insn_length
= initial_insn_length
;
759 memcpy (cie
->initial_instructions
, buf
,
760 initial_insn_length
<= sizeof (cie
->initial_instructions
)
761 ? initial_insn_length
: sizeof (cie
->initial_instructions
));
763 buf
+= initial_insn_length
;
764 ENSURE_NO_RELOCS (buf
);
766 if (!info
->relocatable
)
767 /* Keep info for merging cies. */
768 this_inf
->u
.cie
.u
.full_cie
= cie
;
769 this_inf
->u
.cie
.per_encoding_relative
770 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
774 /* Find the corresponding CIE. */
775 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
776 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
777 if (cie_offset
== cie
->cie_inf
->offset
)
780 /* Ensure this FDE references one of the CIEs in this input
782 REQUIRE (cie
!= local_cies
+ cie_count
);
783 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
784 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
785 this_inf
->add_augmentation_size
786 = cie
->cie_inf
->add_augmentation_size
;
788 ENSURE_NO_RELOCS (buf
);
789 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
793 REQUIRE (GET_RELOC (buf
));
795 /* Chain together the FDEs for each section. */
796 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
797 /* RSEC will be NULL if FDE was cleared out as it was belonging to
798 a discarded SHT_GROUP. */
801 REQUIRE (rsec
->owner
== abfd
);
802 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
803 elf_fde_list (rsec
) = this_inf
;
807 /* Skip the initial location and address range. */
809 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
810 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
812 /* Skip the augmentation size, if present. */
813 if (cie
->augmentation
[0] == 'z')
814 REQUIRE (read_uleb128 (&buf
, end
, &length
));
818 /* Of the supported augmentation characters above, only 'L'
819 adds augmentation data to the FDE. This code would need to
820 be adjusted if any future augmentations do the same thing. */
821 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
824 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
825 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
826 this_inf
->lsda_offset
= buf
- start
;
827 /* If there's no 'z' augmentation, we don't know where the
828 CFA insns begin. Assume no padding. */
829 if (cie
->augmentation
[0] != 'z')
833 /* Skip over the augmentation data. */
834 REQUIRE (skip_bytes (&buf
, end
, length
));
837 buf
= last_fde
+ 4 + hdr_length
;
839 /* For NULL RSEC (cleared FDE belonging to a discarded section)
840 the relocations are commonly cleared. We do not sanity check if
841 all these relocations are cleared as (1) relocations to
842 .gcc_except_table will remain uncleared (they will get dropped
843 with the drop of this unused FDE) and (2) BFD already safely drops
844 relocations of any type to .eh_frame by
845 elf_section_ignore_discarded_relocs.
846 TODO: The .gcc_except_table entries should be also filtered as
847 .eh_frame entries; or GCC could rather use COMDAT for them. */
851 /* Try to interpret the CFA instructions and find the first
852 padding nop. Shrink this_inf's size so that it doesn't
853 include the padding. */
854 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
856 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
857 /* If we don't understand the CFA instructions, we can't know
858 what needs to be adjusted there. */
859 if (insns_end
== NULL
860 /* For the time being we don't support DW_CFA_set_loc in
862 || (set_loc_count
&& this_inf
->cie
))
864 this_inf
->size
-= end
- insns_end
;
865 if (insns_end
!= end
&& this_inf
->cie
)
867 cie
->initial_insn_length
-= end
- insns_end
;
868 cie
->length
-= end
- insns_end
;
871 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
872 || this_inf
->make_relative
))
877 this_inf
->set_loc
= (unsigned int *)
878 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
879 REQUIRE (this_inf
->set_loc
);
880 this_inf
->set_loc
[0] = set_loc_count
;
885 if (*p
== DW_CFA_set_loc
)
886 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
887 REQUIRE (skip_cfa_op (&p
, end
, length
));
891 this_inf
->removed
= 1;
892 this_inf
->fde_encoding
= cie
->fde_encoding
;
893 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
896 BFD_ASSERT (sec_info
->count
== num_entries
);
897 BFD_ASSERT (cie_count
== num_cies
);
899 elf_section_data (sec
)->sec_info
= sec_info
;
900 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
901 if (!info
->relocatable
)
903 /* Keep info for merging cies. */
904 sec_info
->cies
= local_cies
;
910 (*info
->callbacks
->einfo
)
911 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
913 hdr_info
->table
= FALSE
;
924 /* Mark all relocations against CIE or FDE ENT, which occurs in
925 .eh_frame section SEC. COOKIE describes the relocations in SEC;
926 its "rel" field can be changed freely. */
929 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
930 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
931 struct elf_reloc_cookie
*cookie
)
933 /* FIXME: octets_per_byte. */
934 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
935 cookie
->rel
< cookie
->relend
936 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
938 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
944 /* Mark all the relocations against FDEs that relate to code in input
945 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
946 relocations are described by COOKIE. */
949 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
950 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
951 struct elf_reloc_cookie
*cookie
)
953 struct eh_cie_fde
*fde
, *cie
;
955 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
957 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
960 /* At this stage, all cie_inf fields point to local CIEs, so we
961 can use the same cookie to refer to them. */
962 cie
= fde
->u
.fde
.cie_inf
;
963 if (!cie
->u
.cie
.gc_mark
)
965 cie
->u
.cie
.gc_mark
= 1;
966 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
973 /* Input section SEC of ABFD is an .eh_frame section that contains the
974 CIE described by CIE_INF. Return a version of CIE_INF that is going
975 to be kept in the output, adding CIE_INF to the output if necessary.
977 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
978 relocations in REL. */
980 static struct eh_cie_fde
*
981 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
982 struct eh_frame_hdr_info
*hdr_info
,
983 struct elf_reloc_cookie
*cookie
,
984 struct eh_cie_fde
*cie_inf
)
986 unsigned long r_symndx
;
987 struct cie
*cie
, *new_cie
;
988 Elf_Internal_Rela
*rel
;
991 /* Use CIE_INF if we have already decided to keep it. */
992 if (!cie_inf
->removed
)
995 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
996 if (cie_inf
->u
.cie
.merged
)
997 return cie_inf
->u
.cie
.u
.merged_with
;
999 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1001 /* Assume we will need to keep CIE_INF. */
1002 cie_inf
->removed
= 0;
1003 cie_inf
->u
.cie
.u
.sec
= sec
;
1005 /* If we are not merging CIEs, use CIE_INF. */
1009 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1011 bfd_boolean per_binds_local
;
1013 /* Work out the address of personality routine, or at least
1014 enough info that we could calculate the address had we made a
1015 final section layout. The symbol on the reloc is enough,
1016 either the hash for a global, or (bfd id, index) pair for a
1017 local. The assumption here is that no one uses addends on
1019 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1020 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1022 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1023 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1026 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1027 if (r_symndx
>= cookie
->locsymcount
1028 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1030 struct elf_link_hash_entry
*h
;
1032 r_symndx
-= cookie
->extsymoff
;
1033 h
= cookie
->sym_hashes
[r_symndx
];
1035 while (h
->root
.type
== bfd_link_hash_indirect
1036 || h
->root
.type
== bfd_link_hash_warning
)
1037 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1039 cie
->personality
.h
= h
;
1040 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1044 Elf_Internal_Sym
*sym
;
1047 sym
= &cookie
->locsyms
[r_symndx
];
1048 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1049 if (sym_sec
== NULL
)
1052 if (sym_sec
->kept_section
!= NULL
)
1053 sym_sec
= sym_sec
->kept_section
;
1054 if (sym_sec
->output_section
== NULL
)
1057 cie
->local_personality
= 1;
1058 cie
->personality
.sym
.bfd_id
= abfd
->id
;
1059 cie
->personality
.sym
.index
= r_symndx
;
1060 per_binds_local
= TRUE
;
1065 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1066 && (get_elf_backend_data (abfd
)
1067 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1069 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1070 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1074 /* See if we can merge this CIE with an earlier one. */
1075 cie
->output_sec
= sec
->output_section
;
1076 cie_compute_hash (cie
);
1077 if (hdr_info
->cies
== NULL
)
1079 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1080 if (hdr_info
->cies
== NULL
)
1083 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
, cie
->hash
, INSERT
);
1087 new_cie
= (struct cie
*) *loc
;
1088 if (new_cie
== NULL
)
1090 /* Keep CIE_INF and record it in the hash table. */
1091 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1092 if (new_cie
== NULL
)
1095 memcpy (new_cie
, cie
, sizeof (struct cie
));
1100 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1101 cie_inf
->removed
= 1;
1102 cie_inf
->u
.cie
.merged
= 1;
1103 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1104 if (cie_inf
->u
.cie
.make_lsda_relative
)
1105 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1107 return new_cie
->cie_inf
;
1110 /* This function is called for each input file before the .eh_frame
1111 section is relocated. It discards duplicate CIEs and FDEs for discarded
1112 functions. The function returns TRUE iff any entries have been
1116 _bfd_elf_discard_section_eh_frame
1117 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1118 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1119 struct elf_reloc_cookie
*cookie
)
1121 struct eh_cie_fde
*ent
;
1122 struct eh_frame_sec_info
*sec_info
;
1123 struct eh_frame_hdr_info
*hdr_info
;
1124 unsigned int ptr_size
, offset
;
1126 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1129 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1130 if (sec_info
== NULL
)
1133 ptr_size
= (get_elf_backend_data (sec
->owner
)
1134 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1136 hdr_info
= &elf_hash_table (info
)->eh_info
;
1137 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1139 /* There should only be one zero terminator, on the last input
1140 file supplying .eh_frame (crtend.o). Remove any others. */
1141 ent
->removed
= sec
->map_head
.s
!= NULL
;
1145 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1148 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1150 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1151 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1156 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1157 /* FIXME: octets_per_byte. */
1158 BFD_ASSERT (cookie
->rel
< cookie
->relend
1159 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1160 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1165 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1166 && ent
->make_relative
== 0)
1167 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1169 /* If a shared library uses absolute pointers
1170 which we cannot turn into PC relative,
1171 don't create the binary search table,
1172 since it is affected by runtime relocations. */
1173 hdr_info
->table
= FALSE
;
1174 (*info
->callbacks
->einfo
)
1175 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1176 " table being created.\n"), abfd
, sec
);
1179 hdr_info
->fde_count
++;
1180 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1181 cookie
, ent
->u
.fde
.cie_inf
);
1187 free (sec_info
->cies
);
1188 sec_info
->cies
= NULL
;
1192 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1195 ent
->new_offset
= offset
;
1196 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1199 sec
->rawsize
= sec
->size
;
1201 return offset
!= sec
->rawsize
;
1204 /* This function is called for .eh_frame_hdr section after
1205 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1206 input sections. It finalizes the size of .eh_frame_hdr section. */
1209 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1211 struct elf_link_hash_table
*htab
;
1212 struct eh_frame_hdr_info
*hdr_info
;
1215 htab
= elf_hash_table (info
);
1216 hdr_info
= &htab
->eh_info
;
1218 if (hdr_info
->cies
!= NULL
)
1220 htab_delete (hdr_info
->cies
);
1221 hdr_info
->cies
= NULL
;
1224 sec
= hdr_info
->hdr_sec
;
1228 sec
->size
= EH_FRAME_HDR_SIZE
;
1229 if (hdr_info
->table
)
1230 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1232 elf_eh_frame_hdr (abfd
) = sec
;
1236 /* Return true if there is at least one non-empty .eh_frame section in
1237 input files. Can only be called after ld has mapped input to
1238 output sections, and before sections are stripped. */
1240 _bfd_elf_eh_frame_present (struct bfd_link_info
*info
)
1242 asection
*eh
= bfd_get_section_by_name (info
->output_bfd
, ".eh_frame");
1247 /* Count only sections which have at least a single CIE or FDE.
1248 There cannot be any CIE or FDE <= 8 bytes. */
1249 for (eh
= eh
->map_head
.s
; eh
!= NULL
; eh
= eh
->map_head
.s
)
1256 /* This function is called from size_dynamic_sections.
1257 It needs to decide whether .eh_frame_hdr should be output or not,
1258 because when the dynamic symbol table has been sized it is too late
1259 to strip sections. */
1262 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1264 struct elf_link_hash_table
*htab
;
1265 struct eh_frame_hdr_info
*hdr_info
;
1267 htab
= elf_hash_table (info
);
1268 hdr_info
= &htab
->eh_info
;
1269 if (hdr_info
->hdr_sec
== NULL
)
1272 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
)
1273 || !info
->eh_frame_hdr
1274 || !_bfd_elf_eh_frame_present (info
))
1276 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1277 hdr_info
->hdr_sec
= NULL
;
1281 hdr_info
->table
= TRUE
;
1285 /* Adjust an address in the .eh_frame section. Given OFFSET within
1286 SEC, this returns the new offset in the adjusted .eh_frame section,
1287 or -1 if the address refers to a CIE/FDE which has been removed
1288 or to offset with dynamic relocation which is no longer needed. */
1291 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1292 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1296 struct eh_frame_sec_info
*sec_info
;
1297 unsigned int lo
, hi
, mid
;
1299 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1301 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1303 if (offset
>= sec
->rawsize
)
1304 return offset
- sec
->rawsize
+ sec
->size
;
1307 hi
= sec_info
->count
;
1311 mid
= (lo
+ hi
) / 2;
1312 if (offset
< sec_info
->entry
[mid
].offset
)
1315 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1321 BFD_ASSERT (lo
< hi
);
1323 /* FDE or CIE was removed. */
1324 if (sec_info
->entry
[mid
].removed
)
1325 return (bfd_vma
) -1;
1327 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1328 no need for run-time relocation against the personality field. */
1329 if (sec_info
->entry
[mid
].cie
1330 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1331 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1332 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1333 return (bfd_vma
) -2;
1335 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1336 relocation against FDE's initial_location field. */
1337 if (!sec_info
->entry
[mid
].cie
1338 && sec_info
->entry
[mid
].make_relative
1339 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1340 return (bfd_vma
) -2;
1342 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1343 for run-time relocation against LSDA field. */
1344 if (!sec_info
->entry
[mid
].cie
1345 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1346 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1347 + sec_info
->entry
[mid
].lsda_offset
))
1348 return (bfd_vma
) -2;
1350 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1351 relocation against DW_CFA_set_loc's arguments. */
1352 if (sec_info
->entry
[mid
].set_loc
1353 && sec_info
->entry
[mid
].make_relative
1354 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1355 + sec_info
->entry
[mid
].set_loc
[1]))
1359 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1360 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1361 + sec_info
->entry
[mid
].set_loc
[cnt
])
1362 return (bfd_vma
) -2;
1365 /* Any new augmentation bytes go before the first relocation. */
1366 return (offset
+ sec_info
->entry
[mid
].new_offset
1367 - sec_info
->entry
[mid
].offset
1368 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1369 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1372 /* Write out .eh_frame section. This is called with the relocated
1376 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1377 struct bfd_link_info
*info
,
1381 struct eh_frame_sec_info
*sec_info
;
1382 struct elf_link_hash_table
*htab
;
1383 struct eh_frame_hdr_info
*hdr_info
;
1384 unsigned int ptr_size
;
1385 struct eh_cie_fde
*ent
;
1387 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1388 /* FIXME: octets_per_byte. */
1389 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1390 sec
->output_offset
, sec
->size
);
1392 ptr_size
= (get_elf_backend_data (abfd
)
1393 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1394 BFD_ASSERT (ptr_size
!= 0);
1396 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1397 htab
= elf_hash_table (info
);
1398 hdr_info
= &htab
->eh_info
;
1400 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1401 hdr_info
->array
= (struct eh_frame_array_ent
*)
1402 bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1403 if (hdr_info
->array
== NULL
)
1406 /* The new offsets can be bigger or smaller than the original offsets.
1407 We therefore need to make two passes over the section: one backward
1408 pass to move entries up and one forward pass to move entries down.
1409 The two passes won't interfere with each other because entries are
1411 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1412 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1413 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1415 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1416 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1417 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1419 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1421 unsigned char *buf
, *end
;
1422 unsigned int new_size
;
1429 /* Any terminating FDE must be at the end of the section. */
1430 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1434 buf
= contents
+ ent
->new_offset
;
1435 end
= buf
+ ent
->size
;
1436 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1438 /* Update the size. It may be shrinked. */
1439 bfd_put_32 (abfd
, new_size
- 4, buf
);
1441 /* Filling the extra bytes with DW_CFA_nops. */
1442 if (new_size
!= ent
->size
)
1443 memset (end
, 0, new_size
- ent
->size
);
1448 if (ent
->make_relative
1449 || ent
->u
.cie
.make_lsda_relative
1450 || ent
->u
.cie
.per_encoding_relative
)
1453 unsigned int action
, extra_string
, extra_data
;
1454 unsigned int per_width
, per_encoding
;
1456 /* Need to find 'R' or 'L' augmentation's argument and modify
1457 DW_EH_PE_* value. */
1458 action
= ((ent
->make_relative
? 1 : 0)
1459 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1460 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1461 extra_string
= extra_augmentation_string_bytes (ent
);
1462 extra_data
= extra_augmentation_data_bytes (ent
);
1464 /* Skip length, id and version. */
1467 buf
+= strlen (aug
) + 1;
1468 skip_leb128 (&buf
, end
);
1469 skip_leb128 (&buf
, end
);
1470 skip_leb128 (&buf
, end
);
1473 /* The uleb128 will always be a single byte for the kind
1474 of augmentation strings that we're prepared to handle. */
1475 *buf
++ += extra_data
;
1479 /* Make room for the new augmentation string and data bytes. */
1480 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1481 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1482 buf
+= extra_string
;
1483 end
+= extra_string
+ extra_data
;
1485 if (ent
->add_augmentation_size
)
1488 *buf
++ = extra_data
- 1;
1490 if (ent
->u
.cie
.add_fde_encoding
)
1492 BFD_ASSERT (action
& 1);
1494 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
1504 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1505 *buf
= make_pc_relative (*buf
, ptr_size
);
1511 if (ent
->u
.cie
.make_per_encoding_relative
)
1512 *buf
= make_pc_relative (*buf
, ptr_size
);
1513 per_encoding
= *buf
++;
1514 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1515 BFD_ASSERT (per_width
!= 0);
1516 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1517 == ent
->u
.cie
.per_encoding_relative
);
1518 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
1520 + ((buf
- contents
+ per_width
- 1)
1521 & ~((bfd_size_type
) per_width
- 1)));
1526 val
= read_value (abfd
, buf
, per_width
,
1527 get_DW_EH_PE_signed (per_encoding
));
1528 if (ent
->u
.cie
.make_per_encoding_relative
)
1529 val
-= (sec
->output_section
->vma
1530 + sec
->output_offset
1531 + (buf
- contents
));
1534 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1535 val
-= extra_string
+ extra_data
;
1537 write_value (abfd
, buf
, val
, per_width
);
1545 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1546 *buf
= make_pc_relative (*buf
, ptr_size
);
1561 bfd_vma value
, address
;
1564 struct eh_cie_fde
*cie
;
1567 cie
= ent
->u
.fde
.cie_inf
;
1569 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1570 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1571 bfd_put_32 (abfd
, value
, buf
);
1573 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1574 value
= read_value (abfd
, buf
, width
,
1575 get_DW_EH_PE_signed (ent
->fde_encoding
));
1579 switch (ent
->fde_encoding
& 0x70)
1581 case DW_EH_PE_textrel
:
1582 BFD_ASSERT (hdr_info
== NULL
);
1584 case DW_EH_PE_datarel
:
1586 switch (abfd
->arch_info
->arch
)
1589 BFD_ASSERT (elf_gp (abfd
) != 0);
1590 address
+= elf_gp (abfd
);
1593 (*info
->callbacks
->einfo
)
1594 (_("%P: DW_EH_PE_datarel unspecified"
1595 " for this architecture.\n"));
1599 BFD_ASSERT (htab
->hgot
!= NULL
1600 && ((htab
->hgot
->root
.type
1601 == bfd_link_hash_defined
)
1602 || (htab
->hgot
->root
.type
1603 == bfd_link_hash_defweak
)));
1605 += (htab
->hgot
->root
.u
.def
.value
1606 + htab
->hgot
->root
.u
.def
.section
->output_offset
1607 + (htab
->hgot
->root
.u
.def
.section
->output_section
1613 case DW_EH_PE_pcrel
:
1614 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1615 address
+= (sec
->output_section
->vma
1616 + sec
->output_offset
1620 if (ent
->make_relative
)
1621 value
-= (sec
->output_section
->vma
1622 + sec
->output_offset
1623 + ent
->new_offset
+ 8);
1624 write_value (abfd
, buf
, value
, width
);
1631 /* The address calculation may overflow, giving us a
1632 value greater than 4G on a 32-bit target when
1633 dwarf_vma is 64-bit. */
1634 if (sizeof (address
) > 4 && ptr_size
== 4)
1635 address
&= 0xffffffff;
1636 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1637 hdr_info
->array
[hdr_info
->array_count
++].fde
1638 = (sec
->output_section
->vma
1639 + sec
->output_offset
1643 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
1644 || cie
->u
.cie
.make_lsda_relative
)
1646 buf
+= ent
->lsda_offset
;
1647 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1648 value
= read_value (abfd
, buf
, width
,
1649 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1652 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1653 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1654 else if (cie
->u
.cie
.make_lsda_relative
)
1655 value
-= (sec
->output_section
->vma
1656 + sec
->output_offset
1657 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1658 write_value (abfd
, buf
, value
, width
);
1661 else if (ent
->add_augmentation_size
)
1663 /* Skip the PC and length and insert a zero byte for the
1664 augmentation size. */
1666 memmove (buf
+ 1, buf
, end
- buf
);
1672 /* Adjust DW_CFA_set_loc. */
1676 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1677 new_offset
= ent
->new_offset
+ 8
1678 + extra_augmentation_string_bytes (ent
)
1679 + extra_augmentation_data_bytes (ent
);
1681 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1683 buf
= start
+ ent
->set_loc
[cnt
];
1685 value
= read_value (abfd
, buf
, width
,
1686 get_DW_EH_PE_signed (ent
->fde_encoding
));
1690 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
1691 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
1692 if (ent
->make_relative
)
1693 value
-= (sec
->output_section
->vma
1694 + sec
->output_offset
1695 + new_offset
+ ent
->set_loc
[cnt
]);
1696 write_value (abfd
, buf
, value
, width
);
1702 /* We don't align the section to its section alignment since the
1703 runtime library only expects all CIE/FDE records aligned at
1704 the pointer size. _bfd_elf_discard_section_eh_frame should
1705 have padded CIE/FDE records to multiple of pointer size with
1706 size_of_output_cie_fde. */
1707 if ((sec
->size
% ptr_size
) != 0)
1710 /* FIXME: octets_per_byte. */
1711 return bfd_set_section_contents (abfd
, sec
->output_section
,
1712 contents
, (file_ptr
) sec
->output_offset
,
1716 /* Helper function used to sort .eh_frame_hdr search table by increasing
1717 VMA of FDE initial location. */
1720 vma_compare (const void *a
, const void *b
)
1722 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
1723 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
1724 if (p
->initial_loc
> q
->initial_loc
)
1726 if (p
->initial_loc
< q
->initial_loc
)
1731 /* Write out .eh_frame_hdr section. This must be called after
1732 _bfd_elf_write_section_eh_frame has been called on all input
1734 .eh_frame_hdr format:
1735 ubyte version (currently 1)
1736 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1738 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1739 number (or DW_EH_PE_omit if there is no
1740 binary search table computed))
1741 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1742 or DW_EH_PE_omit if not present.
1743 DW_EH_PE_datarel is using address of
1744 .eh_frame_hdr section start as base)
1745 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1746 optionally followed by:
1747 [encoded] fde_count (total number of FDEs in .eh_frame section)
1748 fde_count x [encoded] initial_loc, fde
1749 (array of encoded pairs containing
1750 FDE initial_location field and FDE address,
1751 sorted by increasing initial_loc). */
1754 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1756 struct elf_link_hash_table
*htab
;
1757 struct eh_frame_hdr_info
*hdr_info
;
1759 bfd_boolean retval
= TRUE
;
1761 htab
= elf_hash_table (info
);
1762 hdr_info
= &htab
->eh_info
;
1763 sec
= hdr_info
->hdr_sec
;
1765 if (info
->eh_frame_hdr
&& sec
!= NULL
)
1768 asection
*eh_frame_sec
;
1770 bfd_vma encoded_eh_frame
;
1772 size
= EH_FRAME_HDR_SIZE
;
1773 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1774 size
+= 4 + hdr_info
->fde_count
* 8;
1775 contents
= (bfd_byte
*) bfd_malloc (size
);
1776 if (contents
== NULL
)
1779 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1780 if (eh_frame_sec
== NULL
)
1786 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1789 /* .eh_frame offset. */
1790 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1791 (abfd
, info
, eh_frame_sec
, 0, sec
, 4, &encoded_eh_frame
);
1793 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1795 /* FDE count encoding. */
1796 contents
[2] = DW_EH_PE_udata4
;
1797 /* Search table encoding. */
1798 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
1802 contents
[2] = DW_EH_PE_omit
;
1803 contents
[3] = DW_EH_PE_omit
;
1805 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1807 if (contents
[2] != DW_EH_PE_omit
)
1811 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1812 qsort (hdr_info
->array
, hdr_info
->fde_count
,
1813 sizeof (*hdr_info
->array
), vma_compare
);
1814 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1817 hdr_info
->array
[i
].initial_loc
1818 - sec
->output_section
->vma
,
1819 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1821 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1822 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1826 /* FIXME: octets_per_byte. */
1827 retval
= bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1828 (file_ptr
) sec
->output_offset
,
1832 if (hdr_info
->array
!= NULL
)
1833 free (hdr_info
->array
);
1837 /* Return the width of FDE addresses. This is the default implementation. */
1840 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1842 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1845 /* Decide whether we can use a PC-relative encoding within the given
1846 EH frame section. This is the default implementation. */
1849 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1850 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1851 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1856 /* Select an encoding for the given address. Preference is given to
1857 PC-relative addressing modes. */
1860 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1861 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1862 asection
*osec
, bfd_vma offset
,
1863 asection
*loc_sec
, bfd_vma loc_offset
,
1866 *encoded
= osec
->vma
+ offset
-
1867 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1868 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;