1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2017 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
;
49 struct eh_cie_fde
*cie_inf
;
50 unsigned char per_encoding
;
51 unsigned char lsda_encoding
;
52 unsigned char fde_encoding
;
53 unsigned char initial_insn_length
;
54 unsigned char can_make_lsda_relative
;
55 unsigned char initial_instructions
[50];
60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
61 move onto the next byte. Return true on success. */
63 static inline bfd_boolean
64 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
68 *result
= *((*iter
)++);
72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
73 Return true it was possible to move LENGTH bytes. */
75 static inline bfd_boolean
76 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
78 if ((bfd_size_type
) (end
- *iter
) < length
)
87 /* Move *ITER over an leb128, stopping at END. Return true if the end
88 of the leb128 was found. */
91 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
95 if (!read_byte (iter
, end
, &byte
))
101 /* Like skip_leb128, but treat the leb128 as an unsigned value and
102 store it in *VALUE. */
105 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
110 if (!skip_leb128 (iter
, end
))
116 *value
= (*value
<< 7) | (*--p
& 0x7f);
121 /* Like read_uleb128, but for signed values. */
124 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
129 if (!skip_leb128 (iter
, end
))
133 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
135 *value
= (*value
<< 7) | (*--p
& 0x7f);
140 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
143 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
145 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
147 if ((encoding
& 0x60) == 0x60)
150 switch (encoding
& 7)
152 case DW_EH_PE_udata2
: return 2;
153 case DW_EH_PE_udata4
: return 4;
154 case DW_EH_PE_udata8
: return 8;
155 case DW_EH_PE_absptr
: return ptr_size
;
163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
165 /* Read a width sized value from memory. */
168 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
176 value
= bfd_get_signed_16 (abfd
, buf
);
178 value
= bfd_get_16 (abfd
, buf
);
182 value
= bfd_get_signed_32 (abfd
, buf
);
184 value
= bfd_get_32 (abfd
, buf
);
188 value
= bfd_get_signed_64 (abfd
, buf
);
190 value
= bfd_get_64 (abfd
, buf
);
200 /* Store a width sized value to memory. */
203 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
207 case 2: bfd_put_16 (abfd
, value
, buf
); break;
208 case 4: bfd_put_32 (abfd
, value
, buf
); break;
209 case 8: bfd_put_64 (abfd
, value
, buf
); break;
210 default: BFD_FAIL ();
214 /* Return one if C1 and C2 CIEs can be merged. */
217 cie_eq (const void *e1
, const void *e2
)
219 const struct cie
*c1
= (const struct cie
*) e1
;
220 const struct cie
*c2
= (const struct cie
*) e2
;
222 if (c1
->hash
== c2
->hash
223 && c1
->length
== c2
->length
224 && c1
->version
== c2
->version
225 && c1
->local_personality
== c2
->local_personality
226 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
227 && strcmp (c1
->augmentation
, "eh") != 0
228 && c1
->code_align
== c2
->code_align
229 && c1
->data_align
== c2
->data_align
230 && c1
->ra_column
== c2
->ra_column
231 && c1
->augmentation_size
== c2
->augmentation_size
232 && memcmp (&c1
->personality
, &c2
->personality
,
233 sizeof (c1
->personality
)) == 0
234 && (c1
->cie_inf
->u
.cie
.u
.sec
->output_section
235 == c2
->cie_inf
->u
.cie
.u
.sec
->output_section
)
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
->cie_inf
->u
.cie
.u
.sec
->output_section
, 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. */
315 size_of_output_cie_fde (struct eh_cie_fde
*entry
)
319 if (entry
->size
== 4)
322 + extra_augmentation_string_bytes (entry
)
323 + extra_augmentation_data_bytes (entry
));
326 /* Return the offset of the FDE or CIE after ENT. */
329 next_cie_fde_offset (const struct eh_cie_fde
*ent
,
330 const struct eh_cie_fde
*last
,
336 return ent
->new_offset
;
341 /* Assume that the bytes between *ITER and END are CFA instructions.
342 Try to move *ITER past the first instruction and return true on
343 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
346 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
351 if (!read_byte (iter
, end
, &op
))
354 switch (op
& 0xc0 ? op
& 0xc0 : op
)
357 case DW_CFA_advance_loc
:
359 case DW_CFA_remember_state
:
360 case DW_CFA_restore_state
:
361 case DW_CFA_GNU_window_save
:
366 case DW_CFA_restore_extended
:
367 case DW_CFA_undefined
:
368 case DW_CFA_same_value
:
369 case DW_CFA_def_cfa_register
:
370 case DW_CFA_def_cfa_offset
:
371 case DW_CFA_def_cfa_offset_sf
:
372 case DW_CFA_GNU_args_size
:
373 /* One leb128 argument. */
374 return skip_leb128 (iter
, end
);
376 case DW_CFA_val_offset
:
377 case DW_CFA_val_offset_sf
:
378 case DW_CFA_offset_extended
:
379 case DW_CFA_register
:
381 case DW_CFA_offset_extended_sf
:
382 case DW_CFA_GNU_negative_offset_extended
:
383 case DW_CFA_def_cfa_sf
:
384 /* Two leb128 arguments. */
385 return (skip_leb128 (iter
, end
)
386 && skip_leb128 (iter
, end
));
388 case DW_CFA_def_cfa_expression
:
389 /* A variable-length argument. */
390 return (read_uleb128 (iter
, end
, &length
)
391 && skip_bytes (iter
, end
, length
));
393 case DW_CFA_expression
:
394 case DW_CFA_val_expression
:
395 /* A leb128 followed by a variable-length argument. */
396 return (skip_leb128 (iter
, end
)
397 && read_uleb128 (iter
, end
, &length
)
398 && skip_bytes (iter
, end
, length
));
401 return skip_bytes (iter
, end
, encoded_ptr_width
);
403 case DW_CFA_advance_loc1
:
404 return skip_bytes (iter
, end
, 1);
406 case DW_CFA_advance_loc2
:
407 return skip_bytes (iter
, end
, 2);
409 case DW_CFA_advance_loc4
:
410 return skip_bytes (iter
, end
, 4);
412 case DW_CFA_MIPS_advance_loc8
:
413 return skip_bytes (iter
, end
, 8);
420 /* Try to interpret the bytes between BUF and END as CFA instructions.
421 If every byte makes sense, return a pointer to the first DW_CFA_nop
422 padding byte, or END if there is no padding. Return null otherwise.
423 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
426 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
427 unsigned int *set_loc_count
)
433 if (*buf
== DW_CFA_nop
)
437 if (*buf
== DW_CFA_set_loc
)
439 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
446 /* Convert absolute encoding ENCODING into PC-relative form.
447 SIZE is the size of a pointer. */
450 make_pc_relative (unsigned char encoding
, unsigned int ptr_size
)
452 if ((encoding
& 0x7f) == DW_EH_PE_absptr
)
456 encoding
|= DW_EH_PE_sdata2
;
459 encoding
|= DW_EH_PE_sdata4
;
462 encoding
|= DW_EH_PE_sdata8
;
465 return encoding
| DW_EH_PE_pcrel
;
468 /* Examine each .eh_frame_entry section and discard those
469 those that are marked SEC_EXCLUDE. */
472 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info
*hdr_info
)
475 for (i
= 0; i
< hdr_info
->array_count
; i
++)
477 if (hdr_info
->u
.compact
.entries
[i
]->flags
& SEC_EXCLUDE
)
480 for (j
= i
+ 1; j
< hdr_info
->array_count
; j
++)
481 hdr_info
->u
.compact
.entries
[j
-1] = hdr_info
->u
.compact
.entries
[j
];
483 hdr_info
->array_count
--;
484 hdr_info
->u
.compact
.entries
[hdr_info
->array_count
] = NULL
;
490 /* Add a .eh_frame_entry section. */
493 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info
*hdr_info
,
496 if (hdr_info
->array_count
== hdr_info
->u
.compact
.allocated_entries
)
498 if (hdr_info
->u
.compact
.allocated_entries
== 0)
500 hdr_info
->frame_hdr_is_compact
= TRUE
;
501 hdr_info
->u
.compact
.allocated_entries
= 2;
502 hdr_info
->u
.compact
.entries
=
503 bfd_malloc (hdr_info
->u
.compact
.allocated_entries
504 * sizeof (hdr_info
->u
.compact
.entries
[0]));
508 hdr_info
->u
.compact
.allocated_entries
*= 2;
509 hdr_info
->u
.compact
.entries
=
510 bfd_realloc (hdr_info
->u
.compact
.entries
,
511 hdr_info
->u
.compact
.allocated_entries
512 * sizeof (hdr_info
->u
.compact
.entries
[0]));
515 BFD_ASSERT (hdr_info
->u
.compact
.entries
);
518 hdr_info
->u
.compact
.entries
[hdr_info
->array_count
++] = sec
;
521 /* Parse a .eh_frame_entry section. Figure out which text section it
525 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info
*info
,
526 asection
*sec
, struct elf_reloc_cookie
*cookie
)
528 struct elf_link_hash_table
*htab
;
529 struct eh_frame_hdr_info
*hdr_info
;
530 unsigned long r_symndx
;
533 htab
= elf_hash_table (info
);
534 hdr_info
= &htab
->eh_info
;
537 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
542 if (sec
->output_section
&& bfd_is_abs_section (sec
->output_section
))
544 /* At least one of the sections is being discarded from the
545 link, so we should just ignore them. */
549 if (cookie
->rel
== cookie
->relend
)
552 /* The first relocation is the function start. */
553 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
554 if (r_symndx
== STN_UNDEF
)
557 text_sec
= _bfd_elf_section_for_symbol (cookie
, r_symndx
, FALSE
);
559 if (text_sec
== NULL
)
562 elf_section_eh_frame_entry (text_sec
) = sec
;
563 if (text_sec
->output_section
564 && bfd_is_abs_section (text_sec
->output_section
))
565 sec
->flags
|= SEC_EXCLUDE
;
567 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME_ENTRY
;
568 elf_section_data (sec
)->sec_info
= text_sec
;
569 bfd_elf_record_eh_frame_entry (hdr_info
, sec
);
573 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
574 information in the section's sec_info field on success. COOKIE
575 describes the relocations in SEC. */
578 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
579 asection
*sec
, struct elf_reloc_cookie
*cookie
)
581 #define REQUIRE(COND) \
584 goto free_no_table; \
587 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
589 struct eh_cie_fde
*this_inf
;
590 unsigned int hdr_length
, hdr_id
;
591 unsigned int cie_count
;
592 struct cie
*cie
, *local_cies
= NULL
;
593 struct elf_link_hash_table
*htab
;
594 struct eh_frame_hdr_info
*hdr_info
;
595 struct eh_frame_sec_info
*sec_info
= NULL
;
596 unsigned int ptr_size
;
597 unsigned int num_cies
;
598 unsigned int num_entries
;
599 elf_gc_mark_hook_fn gc_mark_hook
;
601 htab
= elf_hash_table (info
);
602 hdr_info
= &htab
->eh_info
;
605 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
607 /* This file does not contain .eh_frame information. */
611 if (bfd_is_abs_section (sec
->output_section
))
613 /* At least one of the sections is being discarded from the
614 link, so we should just ignore them. */
618 /* Read the frame unwind information from abfd. */
620 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
623 && bfd_get_32 (abfd
, ehbuf
) == 0
624 && cookie
->rel
== cookie
->relend
)
626 /* Empty .eh_frame section. */
631 /* If .eh_frame section size doesn't fit into int, we cannot handle
632 it (it would need to use 64-bit .eh_frame format anyway). */
633 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
635 ptr_size
= (get_elf_backend_data (abfd
)
636 ->elf_backend_eh_frame_address_size (abfd
, sec
));
637 REQUIRE (ptr_size
!= 0);
639 /* Go through the section contents and work out how many FDEs and
642 end
= ehbuf
+ sec
->size
;
649 /* Read the length of the entry. */
650 REQUIRE (skip_bytes (&buf
, end
, 4));
651 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
653 /* 64-bit .eh_frame is not supported. */
654 REQUIRE (hdr_length
!= 0xffffffff);
658 REQUIRE (skip_bytes (&buf
, end
, 4));
659 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
663 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
666 sec_info
= (struct eh_frame_sec_info
*)
667 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
668 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
671 /* We need to have a "struct cie" for each CIE in this section. */
672 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
673 REQUIRE (local_cies
);
675 /* FIXME: octets_per_byte. */
676 #define ENSURE_NO_RELOCS(buf) \
677 while (cookie->rel < cookie->relend \
678 && (cookie->rel->r_offset \
679 < (bfd_size_type) ((buf) - ehbuf))) \
681 REQUIRE (cookie->rel->r_info == 0); \
685 /* FIXME: octets_per_byte. */
686 #define SKIP_RELOCS(buf) \
687 while (cookie->rel < cookie->relend \
688 && (cookie->rel->r_offset \
689 < (bfd_size_type) ((buf) - ehbuf))) \
692 /* FIXME: octets_per_byte. */
693 #define GET_RELOC(buf) \
694 ((cookie->rel < cookie->relend \
695 && (cookie->rel->r_offset \
696 == (bfd_size_type) ((buf) - ehbuf))) \
697 ? cookie->rel : NULL)
701 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
702 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
705 bfd_byte
*start
, *insns
, *insns_end
;
706 bfd_size_type length
;
707 unsigned int set_loc_count
;
709 this_inf
= sec_info
->entry
+ sec_info
->count
;
712 /* Read the length of the entry. */
713 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
714 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
716 /* The CIE/FDE must be fully contained in this input section. */
717 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
718 end
= buf
+ hdr_length
;
720 this_inf
->offset
= last_fde
- ehbuf
;
721 this_inf
->size
= 4 + hdr_length
;
722 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
726 /* A zero-length CIE should only be found at the end of
728 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
729 ENSURE_NO_RELOCS (buf
);
734 REQUIRE (skip_bytes (&buf
, end
, 4));
735 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
739 unsigned int initial_insn_length
;
744 /* Point CIE to one of the section-local cie structures. */
745 cie
= local_cies
+ cie_count
++;
747 cie
->cie_inf
= this_inf
;
748 cie
->length
= hdr_length
;
750 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
752 /* Cannot handle unknown versions. */
753 REQUIRE (cie
->version
== 1
755 || cie
->version
== 4);
756 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
758 strcpy (cie
->augmentation
, (char *) buf
);
759 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
760 this_inf
->u
.cie
.aug_str_len
= buf
- start
- 1;
761 ENSURE_NO_RELOCS (buf
);
762 if (buf
[0] == 'e' && buf
[1] == 'h')
764 /* GCC < 3.0 .eh_frame CIE */
765 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
766 is private to each CIE, so we don't need it for anything.
768 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
771 if (cie
->version
>= 4)
773 REQUIRE (buf
+ 1 < end
);
774 REQUIRE (buf
[0] == ptr_size
);
775 REQUIRE (buf
[1] == 0);
778 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
779 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
780 if (cie
->version
== 1)
783 cie
->ra_column
= *buf
++;
786 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
787 ENSURE_NO_RELOCS (buf
);
788 cie
->lsda_encoding
= DW_EH_PE_omit
;
789 cie
->fde_encoding
= DW_EH_PE_omit
;
790 cie
->per_encoding
= DW_EH_PE_omit
;
791 aug
= cie
->augmentation
;
792 if (aug
[0] != 'e' || aug
[1] != 'h')
797 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
798 ENSURE_NO_RELOCS (buf
);
805 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
806 ENSURE_NO_RELOCS (buf
);
807 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
810 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
811 ENSURE_NO_RELOCS (buf
);
812 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
820 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
821 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
824 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
826 length
= -(buf
- ehbuf
) & (per_width
- 1);
827 REQUIRE (skip_bytes (&buf
, end
, length
));
829 this_inf
->u
.cie
.per_encoding_aligned8
= 1;
831 this_inf
->u
.cie
.personality_offset
= buf
- start
;
832 ENSURE_NO_RELOCS (buf
);
833 /* Ensure we have a reloc here. */
834 REQUIRE (GET_RELOC (buf
));
835 cie
->personality
.reloc_index
836 = cookie
->rel
- cookie
->rels
;
837 /* Cope with MIPS-style composite relocations. */
840 while (GET_RELOC (buf
) != NULL
);
841 REQUIRE (skip_bytes (&buf
, end
, per_width
));
845 /* Unrecognized augmentation. Better bail out. */
849 this_inf
->u
.cie
.aug_data_len
850 = buf
- start
- 1 - this_inf
->u
.cie
.aug_str_len
;
852 /* For shared libraries, try to get rid of as many RELATIVE relocs
854 if (bfd_link_pic (info
)
855 && (get_elf_backend_data (abfd
)
856 ->elf_backend_can_make_relative_eh_frame
859 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
860 this_inf
->make_relative
= 1;
861 /* If the CIE doesn't already have an 'R' entry, it's fairly
862 easy to add one, provided that there's no aligned data
863 after the augmentation string. */
864 else if (cie
->fde_encoding
== DW_EH_PE_omit
865 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
867 if (*cie
->augmentation
== 0)
868 this_inf
->add_augmentation_size
= 1;
869 this_inf
->u
.cie
.add_fde_encoding
= 1;
870 this_inf
->make_relative
= 1;
873 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
874 cie
->can_make_lsda_relative
= 1;
877 /* If FDE encoding was not specified, it defaults to
879 if (cie
->fde_encoding
== DW_EH_PE_omit
)
880 cie
->fde_encoding
= DW_EH_PE_absptr
;
882 initial_insn_length
= end
- buf
;
883 cie
->initial_insn_length
= initial_insn_length
;
884 memcpy (cie
->initial_instructions
, buf
,
885 initial_insn_length
<= sizeof (cie
->initial_instructions
)
886 ? initial_insn_length
: sizeof (cie
->initial_instructions
));
888 buf
+= initial_insn_length
;
889 ENSURE_NO_RELOCS (buf
);
891 if (!bfd_link_relocatable (info
))
893 /* Keep info for merging cies. */
894 this_inf
->u
.cie
.u
.full_cie
= cie
;
895 this_inf
->u
.cie
.per_encoding_relative
896 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
901 /* Find the corresponding CIE. */
902 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
903 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
904 if (cie_offset
== cie
->cie_inf
->offset
)
907 /* Ensure this FDE references one of the CIEs in this input
909 REQUIRE (cie
!= local_cies
+ cie_count
);
910 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
911 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
912 this_inf
->add_augmentation_size
913 = cie
->cie_inf
->add_augmentation_size
;
915 ENSURE_NO_RELOCS (buf
);
916 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
920 REQUIRE (GET_RELOC (buf
));
922 /* Chain together the FDEs for each section. */
923 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
,
925 /* RSEC will be NULL if FDE was cleared out as it was belonging to
926 a discarded SHT_GROUP. */
929 REQUIRE (rsec
->owner
== abfd
);
930 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
931 elf_fde_list (rsec
) = this_inf
;
935 /* Skip the initial location and address range. */
937 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
938 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
940 SKIP_RELOCS (buf
- length
);
941 if (!GET_RELOC (buf
- length
)
942 && read_value (abfd
, buf
- length
, length
, FALSE
) == 0)
944 (*info
->callbacks
->minfo
)
945 /* xgettext:c-format */
946 (_("discarding zero address range FDE in %B(%A).\n"),
948 this_inf
->u
.fde
.cie_inf
= NULL
;
951 /* Skip the augmentation size, if present. */
952 if (cie
->augmentation
[0] == 'z')
953 REQUIRE (read_uleb128 (&buf
, end
, &length
));
957 /* Of the supported augmentation characters above, only 'L'
958 adds augmentation data to the FDE. This code would need to
959 be adjusted if any future augmentations do the same thing. */
960 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
963 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
964 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
965 this_inf
->lsda_offset
= buf
- start
;
966 /* If there's no 'z' augmentation, we don't know where the
967 CFA insns begin. Assume no padding. */
968 if (cie
->augmentation
[0] != 'z')
972 /* Skip over the augmentation data. */
973 REQUIRE (skip_bytes (&buf
, end
, length
));
976 buf
= last_fde
+ 4 + hdr_length
;
978 /* For NULL RSEC (cleared FDE belonging to a discarded section)
979 the relocations are commonly cleared. We do not sanity check if
980 all these relocations are cleared as (1) relocations to
981 .gcc_except_table will remain uncleared (they will get dropped
982 with the drop of this unused FDE) and (2) BFD already safely drops
983 relocations of any type to .eh_frame by
984 elf_section_ignore_discarded_relocs.
985 TODO: The .gcc_except_table entries should be also filtered as
986 .eh_frame entries; or GCC could rather use COMDAT for them. */
990 /* Try to interpret the CFA instructions and find the first
991 padding nop. Shrink this_inf's size so that it doesn't
992 include the padding. */
993 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
995 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
996 /* If we don't understand the CFA instructions, we can't know
997 what needs to be adjusted there. */
998 if (insns_end
== NULL
999 /* For the time being we don't support DW_CFA_set_loc in
1000 CIE instructions. */
1001 || (set_loc_count
&& this_inf
->cie
))
1003 this_inf
->size
-= end
- insns_end
;
1004 if (insns_end
!= end
&& this_inf
->cie
)
1006 cie
->initial_insn_length
-= end
- insns_end
;
1007 cie
->length
-= end
- insns_end
;
1010 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
1011 || this_inf
->make_relative
))
1016 this_inf
->set_loc
= (unsigned int *)
1017 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
1018 REQUIRE (this_inf
->set_loc
);
1019 this_inf
->set_loc
[0] = set_loc_count
;
1024 if (*p
== DW_CFA_set_loc
)
1025 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
1026 REQUIRE (skip_cfa_op (&p
, end
, length
));
1030 this_inf
->removed
= 1;
1031 this_inf
->fde_encoding
= cie
->fde_encoding
;
1032 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
1035 BFD_ASSERT (sec_info
->count
== num_entries
);
1036 BFD_ASSERT (cie_count
== num_cies
);
1038 elf_section_data (sec
)->sec_info
= sec_info
;
1039 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
1040 if (!bfd_link_relocatable (info
))
1042 /* Keep info for merging cies. */
1043 sec_info
->cies
= local_cies
;
1049 (*info
->callbacks
->einfo
)
1050 /* xgettext:c-format */
1051 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1053 hdr_info
->u
.dwarf
.table
= FALSE
;
1064 /* Order eh_frame_hdr entries by the VMA of their text section. */
1067 cmp_eh_frame_hdr (const void *a
, const void *b
)
1073 sec
= *(asection
*const *)a
;
1074 sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1075 text_a
= sec
->output_section
->vma
+ sec
->output_offset
;
1076 sec
= *(asection
*const *)b
;
1077 sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1078 text_b
= sec
->output_section
->vma
+ sec
->output_offset
;
1080 if (text_a
< text_b
)
1082 return text_a
> text_b
;
1086 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1087 referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1090 add_eh_frame_hdr_terminator (asection
*sec
,
1099 /* See if there is a gap (presumably a text section without unwind info)
1100 between these two entries. */
1101 text_sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1102 end
= text_sec
->output_section
->vma
+ text_sec
->output_offset
1104 text_sec
= (asection
*) elf_section_data (next
)->sec_info
;
1105 next_start
= text_sec
->output_section
->vma
+ text_sec
->output_offset
;
1106 if (end
== next_start
)
1110 /* Add space for a CANTUNWIND terminator. */
1112 sec
->rawsize
= sec
->size
;
1114 bfd_set_section_size (sec
->owner
, sec
, sec
->size
+ 8);
1117 /* Finish a pass over all .eh_frame_entry sections. */
1120 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
1122 struct eh_frame_hdr_info
*hdr_info
;
1125 hdr_info
= &elf_hash_table (info
)->eh_info
;
1127 if (info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
1128 || hdr_info
->array_count
== 0)
1131 bfd_elf_discard_eh_frame_entry (hdr_info
);
1133 qsort (hdr_info
->u
.compact
.entries
, hdr_info
->array_count
,
1134 sizeof (asection
*), cmp_eh_frame_hdr
);
1136 for (i
= 0; i
< hdr_info
->array_count
- 1; i
++)
1138 add_eh_frame_hdr_terminator (hdr_info
->u
.compact
.entries
[i
],
1139 hdr_info
->u
.compact
.entries
[i
+ 1]);
1142 /* Add a CANTUNWIND terminator after the last entry. */
1143 add_eh_frame_hdr_terminator (hdr_info
->u
.compact
.entries
[i
], NULL
);
1147 /* Mark all relocations against CIE or FDE ENT, which occurs in
1148 .eh_frame section SEC. COOKIE describes the relocations in SEC;
1149 its "rel" field can be changed freely. */
1152 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
1153 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
1154 struct elf_reloc_cookie
*cookie
)
1156 /* FIXME: octets_per_byte. */
1157 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1158 cookie
->rel
< cookie
->relend
1159 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
1161 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
1167 /* Mark all the relocations against FDEs that relate to code in input
1168 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1169 relocations are described by COOKIE. */
1172 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
1173 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
1174 struct elf_reloc_cookie
*cookie
)
1176 struct eh_cie_fde
*fde
, *cie
;
1178 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
1180 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
1183 /* At this stage, all cie_inf fields point to local CIEs, so we
1184 can use the same cookie to refer to them. */
1185 cie
= fde
->u
.fde
.cie_inf
;
1186 if (cie
!= NULL
&& !cie
->u
.cie
.gc_mark
)
1188 cie
->u
.cie
.gc_mark
= 1;
1189 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
1196 /* Input section SEC of ABFD is an .eh_frame section that contains the
1197 CIE described by CIE_INF. Return a version of CIE_INF that is going
1198 to be kept in the output, adding CIE_INF to the output if necessary.
1200 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1201 relocations in REL. */
1203 static struct eh_cie_fde
*
1204 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1205 struct eh_frame_hdr_info
*hdr_info
,
1206 struct elf_reloc_cookie
*cookie
,
1207 struct eh_cie_fde
*cie_inf
)
1209 unsigned long r_symndx
;
1210 struct cie
*cie
, *new_cie
;
1211 Elf_Internal_Rela
*rel
;
1214 /* Use CIE_INF if we have already decided to keep it. */
1215 if (!cie_inf
->removed
)
1218 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1219 if (cie_inf
->u
.cie
.merged
)
1220 return cie_inf
->u
.cie
.u
.merged_with
;
1222 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1224 /* Assume we will need to keep CIE_INF. */
1225 cie_inf
->removed
= 0;
1226 cie_inf
->u
.cie
.u
.sec
= sec
;
1228 /* If we are not merging CIEs, use CIE_INF. */
1232 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1234 bfd_boolean per_binds_local
;
1236 /* Work out the address of personality routine, or at least
1237 enough info that we could calculate the address had we made a
1238 final section layout. The symbol on the reloc is enough,
1239 either the hash for a global, or (bfd id, index) pair for a
1240 local. The assumption here is that no one uses addends on
1242 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1243 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1245 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1246 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1249 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1250 if (r_symndx
>= cookie
->locsymcount
1251 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1253 struct elf_link_hash_entry
*h
;
1255 r_symndx
-= cookie
->extsymoff
;
1256 h
= cookie
->sym_hashes
[r_symndx
];
1258 while (h
->root
.type
== bfd_link_hash_indirect
1259 || h
->root
.type
== bfd_link_hash_warning
)
1260 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1262 cie
->personality
.h
= h
;
1263 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1267 Elf_Internal_Sym
*sym
;
1270 sym
= &cookie
->locsyms
[r_symndx
];
1271 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1272 if (sym_sec
== NULL
)
1275 if (sym_sec
->kept_section
!= NULL
)
1276 sym_sec
= sym_sec
->kept_section
;
1277 if (sym_sec
->output_section
== NULL
)
1280 cie
->local_personality
= 1;
1281 cie
->personality
.sym
.bfd_id
= abfd
->id
;
1282 cie
->personality
.sym
.index
= r_symndx
;
1283 per_binds_local
= TRUE
;
1287 && bfd_link_pic (info
)
1288 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1289 && (get_elf_backend_data (abfd
)
1290 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1292 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1293 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1297 /* See if we can merge this CIE with an earlier one. */
1298 cie_compute_hash (cie
);
1299 if (hdr_info
->u
.dwarf
.cies
== NULL
)
1301 hdr_info
->u
.dwarf
.cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1302 if (hdr_info
->u
.dwarf
.cies
== NULL
)
1305 loc
= htab_find_slot_with_hash (hdr_info
->u
.dwarf
.cies
, cie
,
1310 new_cie
= (struct cie
*) *loc
;
1311 if (new_cie
== NULL
)
1313 /* Keep CIE_INF and record it in the hash table. */
1314 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1315 if (new_cie
== NULL
)
1318 memcpy (new_cie
, cie
, sizeof (struct cie
));
1323 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1324 cie_inf
->removed
= 1;
1325 cie_inf
->u
.cie
.merged
= 1;
1326 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1327 if (cie_inf
->u
.cie
.make_lsda_relative
)
1328 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1330 return new_cie
->cie_inf
;
1333 /* For a given OFFSET in SEC, return the delta to the new location
1334 after .eh_frame editing. */
1336 static bfd_signed_vma
1337 offset_adjust (bfd_vma offset
, const asection
*sec
)
1339 struct eh_frame_sec_info
*sec_info
1340 = (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1341 unsigned int lo
, hi
, mid
;
1342 struct eh_cie_fde
*ent
;
1343 bfd_signed_vma delta
;
1346 hi
= sec_info
->count
;
1352 mid
= (lo
+ hi
) / 2;
1353 ent
= &sec_info
->entry
[mid
];
1354 if (offset
< ent
->offset
)
1356 else if (mid
+ 1 >= hi
)
1358 else if (offset
>= ent
[1].offset
)
1365 delta
= (bfd_vma
) ent
->new_offset
- (bfd_vma
) ent
->offset
;
1366 else if (ent
->cie
&& ent
->u
.cie
.merged
)
1368 struct eh_cie_fde
*cie
= ent
->u
.cie
.u
.merged_with
;
1369 delta
= ((bfd_vma
) cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
1370 - (bfd_vma
) ent
->offset
- sec
->output_offset
);
1374 /* Is putting the symbol on the next entry best for a deleted
1376 struct eh_cie_fde
*last
= sec_info
->entry
+ sec_info
->count
;
1377 delta
= ((bfd_vma
) next_cie_fde_offset (ent
, last
, sec
)
1378 - (bfd_vma
) ent
->offset
);
1382 /* Account for editing within this CIE/FDE. */
1383 offset
-= ent
->offset
;
1387 = ent
->add_augmentation_size
+ ent
->u
.cie
.add_fde_encoding
;
1389 || offset
<= 9u + ent
->u
.cie
.aug_str_len
)
1392 if (offset
<= 9u + ent
->u
.cie
.aug_str_len
+ ent
->u
.cie
.aug_data_len
)
1398 unsigned int ptr_size
, width
, extra
= ent
->add_augmentation_size
;
1399 if (offset
<= 12 || extra
== 0)
1401 ptr_size
= (get_elf_backend_data (sec
->owner
)
1402 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1403 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1404 if (offset
<= 8 + 2 * width
)
1412 /* Adjust a global symbol defined in .eh_frame, so that it stays
1413 relative to its original CIE/FDE. It is assumed that a symbol
1414 defined at the beginning of a CIE/FDE belongs to that CIE/FDE
1415 rather than marking the end of the previous CIE/FDE. This matters
1416 when a CIE is merged with a previous CIE, since the symbol is
1417 moved to the merged CIE. */
1420 _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry
*h
,
1421 void *arg ATTRIBUTE_UNUSED
)
1424 bfd_signed_vma delta
;
1426 if (h
->root
.type
!= bfd_link_hash_defined
1427 && h
->root
.type
!= bfd_link_hash_defweak
)
1430 sym_sec
= h
->root
.u
.def
.section
;
1431 if (sym_sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
1432 || elf_section_data (sym_sec
)->sec_info
== NULL
)
1435 delta
= offset_adjust (h
->root
.u
.def
.value
, sym_sec
);
1436 h
->root
.u
.def
.value
+= delta
;
1441 /* The same for all local symbols defined in .eh_frame. Returns true
1442 if any symbol was changed. */
1445 adjust_eh_frame_local_symbols (const asection
*sec
,
1446 struct elf_reloc_cookie
*cookie
)
1449 Elf_Internal_Sym
*sym
;
1450 Elf_Internal_Sym
*end_sym
;
1453 shndx
= elf_section_data (sec
)->this_idx
;
1454 end_sym
= cookie
->locsyms
+ cookie
->locsymcount
;
1455 for (sym
= cookie
->locsyms
+ 1; sym
< end_sym
; ++sym
)
1456 if (sym
->st_info
<= ELF_ST_INFO (STB_LOCAL
, STT_OBJECT
)
1457 && sym
->st_shndx
== shndx
)
1459 bfd_signed_vma delta
= offset_adjust (sym
->st_value
, sec
);
1464 sym
->st_value
+= delta
;
1470 /* This function is called for each input file before the .eh_frame
1471 section is relocated. It discards duplicate CIEs and FDEs for discarded
1472 functions. The function returns TRUE iff any entries have been
1476 _bfd_elf_discard_section_eh_frame
1477 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1478 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1479 struct elf_reloc_cookie
*cookie
)
1481 struct eh_cie_fde
*ent
;
1482 struct eh_frame_sec_info
*sec_info
;
1483 struct eh_frame_hdr_info
*hdr_info
;
1484 unsigned int ptr_size
, offset
, eh_alignment
;
1487 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1490 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1491 if (sec_info
== NULL
)
1494 ptr_size
= (get_elf_backend_data (sec
->owner
)
1495 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1497 hdr_info
= &elf_hash_table (info
)->eh_info
;
1498 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1500 /* There should only be one zero terminator, on the last input
1501 file supplying .eh_frame (crtend.o). Remove any others. */
1502 ent
->removed
= sec
->map_head
.s
!= NULL
;
1503 else if (!ent
->cie
&& ent
->u
.fde
.cie_inf
!= NULL
)
1506 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1509 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1511 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1512 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1517 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1518 /* FIXME: octets_per_byte. */
1519 BFD_ASSERT (cookie
->rel
< cookie
->relend
1520 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1521 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1525 if (bfd_link_pic (info
)
1526 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1527 && ent
->make_relative
== 0)
1528 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1530 static int num_warnings_issued
= 0;
1532 /* If a shared library uses absolute pointers
1533 which we cannot turn into PC relative,
1534 don't create the binary search table,
1535 since it is affected by runtime relocations. */
1536 hdr_info
->u
.dwarf
.table
= FALSE
;
1537 if (num_warnings_issued
< 10)
1539 (*info
->callbacks
->einfo
)
1540 /* xgettext:c-format */
1541 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1542 " table being created.\n"), abfd
, sec
);
1543 num_warnings_issued
++;
1545 else if (num_warnings_issued
== 10)
1547 (*info
->callbacks
->einfo
)
1548 (_("%P: Further warnings about FDE encoding preventing .eh_frame_hdr generation dropped.\n"));
1549 num_warnings_issued
++;
1553 hdr_info
->u
.dwarf
.fde_count
++;
1554 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1555 cookie
, ent
->u
.fde
.cie_inf
);
1561 free (sec_info
->cies
);
1562 sec_info
->cies
= NULL
;
1565 /* It may be that some .eh_frame input section has greater alignment
1566 than other .eh_frame sections. In that case we run the risk of
1567 padding with zeros before that section, which would be seen as a
1568 zero terminator. Alignment padding must be added *inside* the
1569 last FDE instead. For other FDEs we align according to their
1570 encoding, in order to align FDE address range entries naturally. */
1573 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1581 if (ent
->u
.cie
.per_encoding_aligned8
)
1586 eh_alignment
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1587 if (eh_alignment
< 4)
1590 offset
= (offset
+ eh_alignment
- 1) & -eh_alignment
;
1591 ent
->new_offset
= offset
;
1592 if (ent
->new_offset
!= ent
->offset
)
1594 offset
+= size_of_output_cie_fde (ent
);
1597 /* Pad the last FDE out to the output section alignment if there are
1598 following sections, in order to ensure no padding between this
1599 section and the next. (Relies on the output section alignment
1600 being the maximum of all input sections alignments, which is the
1601 case unless someone is overriding alignment via scripts.) */
1603 if (sec
->map_head
.s
!= NULL
1604 && (sec
->map_head
.s
->size
!= 4
1605 || sec
->map_head
.s
->map_head
.s
!= NULL
))
1606 eh_alignment
= 1 << sec
->output_section
->alignment_power
;
1607 offset
= (offset
+ eh_alignment
- 1) & -eh_alignment
;
1608 sec
->rawsize
= sec
->size
;
1610 if (sec
->size
!= sec
->rawsize
)
1613 if (changed
&& adjust_eh_frame_local_symbols (sec
, cookie
))
1615 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1616 symtab_hdr
->contents
= (unsigned char *) cookie
->locsyms
;
1621 /* This function is called for .eh_frame_hdr section after
1622 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1623 input sections. It finalizes the size of .eh_frame_hdr section. */
1626 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1628 struct elf_link_hash_table
*htab
;
1629 struct eh_frame_hdr_info
*hdr_info
;
1632 htab
= elf_hash_table (info
);
1633 hdr_info
= &htab
->eh_info
;
1635 if (!hdr_info
->frame_hdr_is_compact
&& hdr_info
->u
.dwarf
.cies
!= NULL
)
1637 htab_delete (hdr_info
->u
.dwarf
.cies
);
1638 hdr_info
->u
.dwarf
.cies
= NULL
;
1641 sec
= hdr_info
->hdr_sec
;
1645 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
1647 /* For compact frames we only add the header. The actual table comes
1648 from the .eh_frame_entry sections. */
1653 sec
->size
= EH_FRAME_HDR_SIZE
;
1654 if (hdr_info
->u
.dwarf
.table
)
1655 sec
->size
+= 4 + hdr_info
->u
.dwarf
.fde_count
* 8;
1658 elf_eh_frame_hdr (abfd
) = sec
;
1662 /* Return true if there is at least one non-empty .eh_frame section in
1663 input files. Can only be called after ld has mapped input to
1664 output sections, and before sections are stripped. */
1667 _bfd_elf_eh_frame_present (struct bfd_link_info
*info
)
1669 asection
*eh
= bfd_get_section_by_name (info
->output_bfd
, ".eh_frame");
1674 /* Count only sections which have at least a single CIE or FDE.
1675 There cannot be any CIE or FDE <= 8 bytes. */
1676 for (eh
= eh
->map_head
.s
; eh
!= NULL
; eh
= eh
->map_head
.s
)
1683 /* Return true if there is at least one .eh_frame_entry section in
1687 _bfd_elf_eh_frame_entry_present (struct bfd_link_info
*info
)
1692 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1694 for (o
= abfd
->sections
; o
; o
= o
->next
)
1696 const char *name
= bfd_get_section_name (abfd
, o
);
1698 if (strcmp (name
, ".eh_frame_entry")
1699 && !bfd_is_abs_section (o
->output_section
))
1706 /* This function is called from size_dynamic_sections.
1707 It needs to decide whether .eh_frame_hdr should be output or not,
1708 because when the dynamic symbol table has been sized it is too late
1709 to strip sections. */
1712 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1714 struct elf_link_hash_table
*htab
;
1715 struct eh_frame_hdr_info
*hdr_info
;
1716 struct bfd_link_hash_entry
*bh
= NULL
;
1717 struct elf_link_hash_entry
*h
;
1719 htab
= elf_hash_table (info
);
1720 hdr_info
= &htab
->eh_info
;
1721 if (hdr_info
->hdr_sec
== NULL
)
1724 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
)
1725 || info
->eh_frame_hdr_type
== 0
1726 || (info
->eh_frame_hdr_type
== DWARF2_EH_HDR
1727 && !_bfd_elf_eh_frame_present (info
))
1728 || (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
1729 && !_bfd_elf_eh_frame_entry_present (info
)))
1731 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1732 hdr_info
->hdr_sec
= NULL
;
1736 /* Add a hidden symbol so that systems without access to PHDRs can
1738 if (! (_bfd_generic_link_add_one_symbol
1739 (info
, info
->output_bfd
, "__GNU_EH_FRAME_HDR", BSF_LOCAL
,
1740 hdr_info
->hdr_sec
, 0, NULL
, FALSE
, FALSE
, &bh
)))
1743 h
= (struct elf_link_hash_entry
*) bh
;
1745 h
->other
= STV_HIDDEN
;
1746 get_elf_backend_data
1747 (info
->output_bfd
)->elf_backend_hide_symbol (info
, h
, TRUE
);
1749 if (!hdr_info
->frame_hdr_is_compact
)
1750 hdr_info
->u
.dwarf
.table
= TRUE
;
1754 /* Adjust an address in the .eh_frame section. Given OFFSET within
1755 SEC, this returns the new offset in the adjusted .eh_frame section,
1756 or -1 if the address refers to a CIE/FDE which has been removed
1757 or to offset with dynamic relocation which is no longer needed. */
1760 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1761 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1765 struct eh_frame_sec_info
*sec_info
;
1766 unsigned int lo
, hi
, mid
;
1768 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1770 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1772 if (offset
>= sec
->rawsize
)
1773 return offset
- sec
->rawsize
+ sec
->size
;
1776 hi
= sec_info
->count
;
1780 mid
= (lo
+ hi
) / 2;
1781 if (offset
< sec_info
->entry
[mid
].offset
)
1784 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1790 BFD_ASSERT (lo
< hi
);
1792 /* FDE or CIE was removed. */
1793 if (sec_info
->entry
[mid
].removed
)
1794 return (bfd_vma
) -1;
1796 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1797 no need for run-time relocation against the personality field. */
1798 if (sec_info
->entry
[mid
].cie
1799 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1800 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1801 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1802 return (bfd_vma
) -2;
1804 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1805 relocation against FDE's initial_location field. */
1806 if (!sec_info
->entry
[mid
].cie
1807 && sec_info
->entry
[mid
].make_relative
1808 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1809 return (bfd_vma
) -2;
1811 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1812 for run-time relocation against LSDA field. */
1813 if (!sec_info
->entry
[mid
].cie
1814 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1815 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1816 + sec_info
->entry
[mid
].lsda_offset
))
1817 return (bfd_vma
) -2;
1819 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1820 relocation against DW_CFA_set_loc's arguments. */
1821 if (sec_info
->entry
[mid
].set_loc
1822 && sec_info
->entry
[mid
].make_relative
1823 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1824 + sec_info
->entry
[mid
].set_loc
[1]))
1828 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1829 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1830 + sec_info
->entry
[mid
].set_loc
[cnt
])
1831 return (bfd_vma
) -2;
1834 /* Any new augmentation bytes go before the first relocation. */
1835 return (offset
+ sec_info
->entry
[mid
].new_offset
1836 - sec_info
->entry
[mid
].offset
1837 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1838 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1841 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1842 Also check that the contents look sane. */
1845 _bfd_elf_write_section_eh_frame_entry (bfd
*abfd
, struct bfd_link_info
*info
,
1846 asection
*sec
, bfd_byte
*contents
)
1848 const struct elf_backend_data
*bed
;
1849 bfd_byte cantunwind
[8];
1853 asection
*text_sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1856 sec
->rawsize
= sec
->size
;
1858 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME_ENTRY
);
1860 /* Check to make sure that the text section corresponding to this eh_frame_entry
1861 section has not been excluded. In particular, mips16 stub entries will be
1862 excluded outside of the normal process. */
1863 if (sec
->flags
& SEC_EXCLUDE
1864 || text_sec
->flags
& SEC_EXCLUDE
)
1867 if (!bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1868 sec
->output_offset
, sec
->rawsize
))
1871 last_addr
= bfd_get_signed_32 (abfd
, contents
);
1872 /* Check that all the entries are in order. */
1873 for (offset
= 8; offset
< sec
->rawsize
; offset
+= 8)
1875 addr
= bfd_get_signed_32 (abfd
, contents
+ offset
) + offset
;
1876 if (addr
<= last_addr
)
1878 /* xgettext:c-format */
1879 _bfd_error_handler (_("%B: %A not in order"), sec
->owner
, sec
);
1886 addr
= text_sec
->output_section
->vma
+ text_sec
->output_offset
1889 addr
-= (sec
->output_section
->vma
+ sec
->output_offset
+ sec
->rawsize
);
1892 /* xgettext:c-format */
1893 _bfd_error_handler (_("%B: %A invalid input section size"),
1895 bfd_set_error (bfd_error_bad_value
);
1898 if (last_addr
>= addr
+ sec
->rawsize
)
1900 /* xgettext:c-format */
1901 _bfd_error_handler (_("%B: %A points past end of text section"),
1903 bfd_set_error (bfd_error_bad_value
);
1907 if (sec
->size
== sec
->rawsize
)
1910 bed
= get_elf_backend_data (abfd
);
1911 BFD_ASSERT (sec
->size
== sec
->rawsize
+ 8);
1912 BFD_ASSERT ((addr
& 1) == 0);
1913 BFD_ASSERT (bed
->cant_unwind_opcode
);
1915 bfd_put_32 (abfd
, addr
, cantunwind
);
1916 bfd_put_32 (abfd
, (*bed
->cant_unwind_opcode
) (info
), cantunwind
+ 4);
1917 return bfd_set_section_contents (abfd
, sec
->output_section
, cantunwind
,
1918 sec
->output_offset
+ sec
->rawsize
, 8);
1921 /* Write out .eh_frame section. This is called with the relocated
1925 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1926 struct bfd_link_info
*info
,
1930 struct eh_frame_sec_info
*sec_info
;
1931 struct elf_link_hash_table
*htab
;
1932 struct eh_frame_hdr_info
*hdr_info
;
1933 unsigned int ptr_size
;
1934 struct eh_cie_fde
*ent
, *last_ent
;
1936 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1937 /* FIXME: octets_per_byte. */
1938 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1939 sec
->output_offset
, sec
->size
);
1941 ptr_size
= (get_elf_backend_data (abfd
)
1942 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1943 BFD_ASSERT (ptr_size
!= 0);
1945 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1946 htab
= elf_hash_table (info
);
1947 hdr_info
= &htab
->eh_info
;
1949 if (hdr_info
->u
.dwarf
.table
&& hdr_info
->u
.dwarf
.array
== NULL
)
1951 hdr_info
->frame_hdr_is_compact
= FALSE
;
1952 hdr_info
->u
.dwarf
.array
= (struct eh_frame_array_ent
*)
1953 bfd_malloc (hdr_info
->u
.dwarf
.fde_count
1954 * sizeof (*hdr_info
->u
.dwarf
.array
));
1956 if (hdr_info
->u
.dwarf
.array
== NULL
)
1959 /* The new offsets can be bigger or smaller than the original offsets.
1960 We therefore need to make two passes over the section: one backward
1961 pass to move entries up and one forward pass to move entries down.
1962 The two passes won't interfere with each other because entries are
1964 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1965 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1966 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1968 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1969 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1970 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1972 last_ent
= sec_info
->entry
+ sec_info
->count
;
1973 for (ent
= sec_info
->entry
; ent
< last_ent
; ++ent
)
1975 unsigned char *buf
, *end
;
1976 unsigned int new_size
;
1983 /* Any terminating FDE must be at the end of the section. */
1984 BFD_ASSERT (ent
== last_ent
- 1);
1988 buf
= contents
+ ent
->new_offset
;
1989 end
= buf
+ ent
->size
;
1990 new_size
= next_cie_fde_offset (ent
, last_ent
, sec
) - ent
->new_offset
;
1992 /* Update the size. It may be shrinked. */
1993 bfd_put_32 (abfd
, new_size
- 4, buf
);
1995 /* Filling the extra bytes with DW_CFA_nops. */
1996 if (new_size
!= ent
->size
)
1997 memset (end
, 0, new_size
- ent
->size
);
2002 if (ent
->make_relative
2003 || ent
->u
.cie
.make_lsda_relative
2004 || ent
->u
.cie
.per_encoding_relative
)
2007 unsigned int action
, extra_string
, extra_data
;
2008 unsigned int per_width
, per_encoding
;
2010 /* Need to find 'R' or 'L' augmentation's argument and modify
2011 DW_EH_PE_* value. */
2012 action
= ((ent
->make_relative
? 1 : 0)
2013 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
2014 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
2015 extra_string
= extra_augmentation_string_bytes (ent
);
2016 extra_data
= extra_augmentation_data_bytes (ent
);
2018 /* Skip length, id and version. */
2021 buf
+= strlen (aug
) + 1;
2022 skip_leb128 (&buf
, end
);
2023 skip_leb128 (&buf
, end
);
2024 skip_leb128 (&buf
, end
);
2027 /* The uleb128 will always be a single byte for the kind
2028 of augmentation strings that we're prepared to handle. */
2029 *buf
++ += extra_data
;
2033 /* Make room for the new augmentation string and data bytes. */
2034 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
2035 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
2036 buf
+= extra_string
;
2037 end
+= extra_string
+ extra_data
;
2039 if (ent
->add_augmentation_size
)
2042 *buf
++ = extra_data
- 1;
2044 if (ent
->u
.cie
.add_fde_encoding
)
2046 BFD_ASSERT (action
& 1);
2048 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
2058 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
2059 *buf
= make_pc_relative (*buf
, ptr_size
);
2065 if (ent
->u
.cie
.make_per_encoding_relative
)
2066 *buf
= make_pc_relative (*buf
, ptr_size
);
2067 per_encoding
= *buf
++;
2068 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
2069 BFD_ASSERT (per_width
!= 0);
2070 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
2071 == ent
->u
.cie
.per_encoding_relative
);
2072 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
2074 + ((buf
- contents
+ per_width
- 1)
2075 & ~((bfd_size_type
) per_width
- 1)));
2080 val
= read_value (abfd
, buf
, per_width
,
2081 get_DW_EH_PE_signed (per_encoding
));
2082 if (ent
->u
.cie
.make_per_encoding_relative
)
2083 val
-= (sec
->output_section
->vma
2084 + sec
->output_offset
2085 + (buf
- contents
));
2088 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
2089 val
-= extra_string
+ extra_data
;
2091 write_value (abfd
, buf
, val
, per_width
);
2099 BFD_ASSERT (*buf
== ent
->fde_encoding
);
2100 *buf
= make_pc_relative (*buf
, ptr_size
);
2115 bfd_vma value
, address
;
2118 struct eh_cie_fde
*cie
;
2121 cie
= ent
->u
.fde
.cie_inf
;
2123 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
2124 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
2125 bfd_put_32 (abfd
, value
, buf
);
2126 if (bfd_link_relocatable (info
))
2129 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
2130 value
= read_value (abfd
, buf
, width
,
2131 get_DW_EH_PE_signed (ent
->fde_encoding
));
2135 switch (ent
->fde_encoding
& 0x70)
2137 case DW_EH_PE_textrel
:
2138 BFD_ASSERT (hdr_info
== NULL
);
2140 case DW_EH_PE_datarel
:
2142 switch (abfd
->arch_info
->arch
)
2145 BFD_ASSERT (elf_gp (abfd
) != 0);
2146 address
+= elf_gp (abfd
);
2149 (*info
->callbacks
->einfo
)
2150 (_("%P: DW_EH_PE_datarel unspecified"
2151 " for this architecture.\n"));
2155 BFD_ASSERT (htab
->hgot
!= NULL
2156 && ((htab
->hgot
->root
.type
2157 == bfd_link_hash_defined
)
2158 || (htab
->hgot
->root
.type
2159 == bfd_link_hash_defweak
)));
2161 += (htab
->hgot
->root
.u
.def
.value
2162 + htab
->hgot
->root
.u
.def
.section
->output_offset
2163 + (htab
->hgot
->root
.u
.def
.section
->output_section
2169 case DW_EH_PE_pcrel
:
2170 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
2171 address
+= (sec
->output_section
->vma
2172 + sec
->output_offset
2176 if (ent
->make_relative
)
2177 value
-= (sec
->output_section
->vma
2178 + sec
->output_offset
2179 + ent
->new_offset
+ 8);
2180 write_value (abfd
, buf
, value
, width
);
2187 /* The address calculation may overflow, giving us a
2188 value greater than 4G on a 32-bit target when
2189 dwarf_vma is 64-bit. */
2190 if (sizeof (address
) > 4 && ptr_size
== 4)
2191 address
&= 0xffffffff;
2192 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
].initial_loc
2194 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
].range
2195 = read_value (abfd
, buf
+ width
, width
, FALSE
);
2196 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
++].fde
2197 = (sec
->output_section
->vma
2198 + sec
->output_offset
2202 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
2203 || cie
->u
.cie
.make_lsda_relative
)
2205 buf
+= ent
->lsda_offset
;
2206 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
2207 value
= read_value (abfd
, buf
, width
,
2208 get_DW_EH_PE_signed (ent
->lsda_encoding
));
2211 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
2212 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
2213 else if (cie
->u
.cie
.make_lsda_relative
)
2214 value
-= (sec
->output_section
->vma
2215 + sec
->output_offset
2216 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
2217 write_value (abfd
, buf
, value
, width
);
2220 else if (ent
->add_augmentation_size
)
2222 /* Skip the PC and length and insert a zero byte for the
2223 augmentation size. */
2225 memmove (buf
+ 1, buf
, end
- buf
);
2231 /* Adjust DW_CFA_set_loc. */
2235 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
2236 new_offset
= ent
->new_offset
+ 8
2237 + extra_augmentation_string_bytes (ent
)
2238 + extra_augmentation_data_bytes (ent
);
2240 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
2242 buf
= start
+ ent
->set_loc
[cnt
];
2244 value
= read_value (abfd
, buf
, width
,
2245 get_DW_EH_PE_signed (ent
->fde_encoding
));
2249 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
2250 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
2251 if (ent
->make_relative
)
2252 value
-= (sec
->output_section
->vma
2253 + sec
->output_offset
2254 + new_offset
+ ent
->set_loc
[cnt
]);
2255 write_value (abfd
, buf
, value
, width
);
2261 /* FIXME: octets_per_byte. */
2262 return bfd_set_section_contents (abfd
, sec
->output_section
,
2263 contents
, (file_ptr
) sec
->output_offset
,
2267 /* Helper function used to sort .eh_frame_hdr search table by increasing
2268 VMA of FDE initial location. */
2271 vma_compare (const void *a
, const void *b
)
2273 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
2274 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
2275 if (p
->initial_loc
> q
->initial_loc
)
2277 if (p
->initial_loc
< q
->initial_loc
)
2279 if (p
->range
> q
->range
)
2281 if (p
->range
< q
->range
)
2286 /* Reorder .eh_frame_entry sections to match the associated text sections.
2287 This routine is called during the final linking step, just before writing
2288 the contents. At this stage, sections in the eh_frame_hdr_info are already
2289 sorted in order of increasing text section address and so we simply need
2290 to make the .eh_frame_entrys follow that same order. Note that it is
2291 invalid for a linker script to try to force a particular order of
2292 .eh_frame_entry sections. */
2295 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info
*info
)
2297 asection
*sec
= NULL
;
2299 struct eh_frame_hdr_info
*hdr_info
;
2302 struct bfd_link_order
*p
;
2304 hdr_info
= &elf_hash_table (info
)->eh_info
;
2306 if (hdr_info
->hdr_sec
== NULL
2307 || info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
2308 || hdr_info
->array_count
== 0)
2311 /* Change section output offsets to be in text section order. */
2313 osec
= hdr_info
->u
.compact
.entries
[0]->output_section
;
2314 for (i
= 0; i
< hdr_info
->array_count
; i
++)
2316 sec
= hdr_info
->u
.compact
.entries
[i
];
2317 if (sec
->output_section
!= osec
)
2320 (_("Invalid output section for .eh_frame_entry: %A"),
2321 sec
->output_section
);
2324 sec
->output_offset
= offset
;
2325 offset
+= sec
->size
;
2329 /* Fix the link_order to match. */
2330 for (p
= sec
->output_section
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
2332 if (p
->type
!= bfd_indirect_link_order
)
2335 p
->offset
= p
->u
.indirect
.section
->output_offset
;
2336 if (p
->next
!= NULL
)
2343 (_("Invalid contents in %A section"), osec
);
2350 /* The .eh_frame_hdr format for Compact EH frames:
2352 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2353 uint32_t count (Number of entries in table)
2354 [array from .eh_frame_entry sections] */
2357 write_compact_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2359 struct elf_link_hash_table
*htab
;
2360 struct eh_frame_hdr_info
*hdr_info
;
2362 const struct elf_backend_data
*bed
;
2364 bfd_byte contents
[8];
2367 htab
= elf_hash_table (info
);
2368 hdr_info
= &htab
->eh_info
;
2369 sec
= hdr_info
->hdr_sec
;
2374 for (i
= 0; i
< sizeof (contents
); i
++)
2377 contents
[0] = COMPACT_EH_HDR
;
2378 bed
= get_elf_backend_data (abfd
);
2380 BFD_ASSERT (bed
->compact_eh_encoding
);
2381 contents
[1] = (*bed
->compact_eh_encoding
) (info
);
2383 count
= (sec
->output_section
->size
- 8) / 8;
2384 bfd_put_32 (abfd
, count
, contents
+ 4);
2385 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
2386 (file_ptr
) sec
->output_offset
, sec
->size
);
2389 /* The .eh_frame_hdr format for DWARF frames:
2391 ubyte version (currently 1)
2392 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
2394 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2395 number (or DW_EH_PE_omit if there is no
2396 binary search table computed))
2397 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2398 or DW_EH_PE_omit if not present.
2399 DW_EH_PE_datarel is using address of
2400 .eh_frame_hdr section start as base)
2401 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2402 optionally followed by:
2403 [encoded] fde_count (total number of FDEs in .eh_frame section)
2404 fde_count x [encoded] initial_loc, fde
2405 (array of encoded pairs containing
2406 FDE initial_location field and FDE address,
2407 sorted by increasing initial_loc). */
2410 write_dwarf_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2412 struct elf_link_hash_table
*htab
;
2413 struct eh_frame_hdr_info
*hdr_info
;
2415 bfd_boolean retval
= TRUE
;
2417 htab
= elf_hash_table (info
);
2418 hdr_info
= &htab
->eh_info
;
2419 sec
= hdr_info
->hdr_sec
;
2421 asection
*eh_frame_sec
;
2423 bfd_vma encoded_eh_frame
;
2425 size
= EH_FRAME_HDR_SIZE
;
2426 if (hdr_info
->u
.dwarf
.array
2427 && hdr_info
->array_count
== hdr_info
->u
.dwarf
.fde_count
)
2428 size
+= 4 + hdr_info
->u
.dwarf
.fde_count
* 8;
2429 contents
= (bfd_byte
*) bfd_malloc (size
);
2430 if (contents
== NULL
)
2433 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
2434 if (eh_frame_sec
== NULL
)
2440 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
2443 /* .eh_frame offset. */
2444 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
2445 (abfd
, info
, eh_frame_sec
, 0, sec
, 4, &encoded_eh_frame
);
2447 if (hdr_info
->u
.dwarf
.array
2448 && hdr_info
->array_count
== hdr_info
->u
.dwarf
.fde_count
)
2450 /* FDE count encoding. */
2451 contents
[2] = DW_EH_PE_udata4
;
2452 /* Search table encoding. */
2453 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
2457 contents
[2] = DW_EH_PE_omit
;
2458 contents
[3] = DW_EH_PE_omit
;
2460 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
2462 if (contents
[2] != DW_EH_PE_omit
)
2465 bfd_boolean overlap
, overflow
;
2467 bfd_put_32 (abfd
, hdr_info
->u
.dwarf
.fde_count
,
2468 contents
+ EH_FRAME_HDR_SIZE
);
2469 qsort (hdr_info
->u
.dwarf
.array
, hdr_info
->u
.dwarf
.fde_count
,
2470 sizeof (*hdr_info
->u
.dwarf
.array
), vma_compare
);
2473 for (i
= 0; i
< hdr_info
->u
.dwarf
.fde_count
; i
++)
2477 val
= hdr_info
->u
.dwarf
.array
[i
].initial_loc
2478 - sec
->output_section
->vma
;
2479 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
2480 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
2481 && (hdr_info
->u
.dwarf
.array
[i
].initial_loc
2482 != sec
->output_section
->vma
+ val
))
2484 bfd_put_32 (abfd
, val
, contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
2485 val
= hdr_info
->u
.dwarf
.array
[i
].fde
- sec
->output_section
->vma
;
2486 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
2487 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
2488 && (hdr_info
->u
.dwarf
.array
[i
].fde
2489 != sec
->output_section
->vma
+ val
))
2491 bfd_put_32 (abfd
, val
, contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
2493 && (hdr_info
->u
.dwarf
.array
[i
].initial_loc
2494 < (hdr_info
->u
.dwarf
.array
[i
- 1].initial_loc
2495 + hdr_info
->u
.dwarf
.array
[i
- 1].range
)))
2499 (*info
->callbacks
->einfo
) (_("%P: .eh_frame_hdr entry overflow.\n"));
2501 (*info
->callbacks
->einfo
)
2502 (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2503 if (overflow
|| overlap
)
2505 bfd_set_error (bfd_error_bad_value
);
2510 /* FIXME: octets_per_byte. */
2511 if (!bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
2512 (file_ptr
) sec
->output_offset
,
2517 if (hdr_info
->u
.dwarf
.array
!= NULL
)
2518 free (hdr_info
->u
.dwarf
.array
);
2522 /* Write out .eh_frame_hdr section. This must be called after
2523 _bfd_elf_write_section_eh_frame has been called on all input
2524 .eh_frame sections. */
2527 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2529 struct elf_link_hash_table
*htab
;
2530 struct eh_frame_hdr_info
*hdr_info
;
2533 htab
= elf_hash_table (info
);
2534 hdr_info
= &htab
->eh_info
;
2535 sec
= hdr_info
->hdr_sec
;
2537 if (info
->eh_frame_hdr_type
== 0 || sec
== NULL
)
2540 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
2541 return write_compact_eh_frame_hdr (abfd
, info
);
2543 return write_dwarf_eh_frame_hdr (abfd
, info
);
2546 /* Return the width of FDE addresses. This is the default implementation. */
2549 _bfd_elf_eh_frame_address_size (bfd
*abfd
, const asection
*sec ATTRIBUTE_UNUSED
)
2551 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
2554 /* Decide whether we can use a PC-relative encoding within the given
2555 EH frame section. This is the default implementation. */
2558 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
2559 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2560 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
2565 /* Select an encoding for the given address. Preference is given to
2566 PC-relative addressing modes. */
2569 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
2570 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2571 asection
*osec
, bfd_vma offset
,
2572 asection
*loc_sec
, bfd_vma loc_offset
,
2575 *encoded
= osec
->vma
+ offset
-
2576 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
2577 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;