1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2022 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. */
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. */
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
));
622 /* If .eh_frame section size doesn't fit into int, we cannot handle
623 it (it would need to use 64-bit .eh_frame format anyway). */
624 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
626 ptr_size
= (get_elf_backend_data (abfd
)
627 ->elf_backend_eh_frame_address_size (abfd
, sec
));
628 REQUIRE (ptr_size
!= 0);
630 /* Go through the section contents and work out how many FDEs and
633 end
= ehbuf
+ sec
->size
;
640 /* Read the length of the entry. */
641 REQUIRE (skip_bytes (&buf
, end
, 4));
642 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
644 /* 64-bit .eh_frame is not supported. */
645 REQUIRE (hdr_length
!= 0xffffffff);
649 REQUIRE (skip_bytes (&buf
, end
, 4));
650 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
654 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
657 sec_info
= (struct eh_frame_sec_info
*)
658 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
659 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
662 /* We need to have a "struct cie" for each CIE in this section. */
665 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
666 REQUIRE (local_cies
);
669 /* FIXME: octets_per_byte. */
670 #define ENSURE_NO_RELOCS(buf) \
671 while (cookie->rel < cookie->relend \
672 && (cookie->rel->r_offset \
673 < (bfd_size_type) ((buf) - ehbuf))) \
675 REQUIRE (cookie->rel->r_info == 0); \
679 /* FIXME: octets_per_byte. */
680 #define SKIP_RELOCS(buf) \
681 while (cookie->rel < cookie->relend \
682 && (cookie->rel->r_offset \
683 < (bfd_size_type) ((buf) - ehbuf))) \
686 /* FIXME: octets_per_byte. */
687 #define GET_RELOC(buf) \
688 ((cookie->rel < cookie->relend \
689 && (cookie->rel->r_offset \
690 == (bfd_size_type) ((buf) - ehbuf))) \
691 ? cookie->rel : NULL)
695 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
696 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
699 bfd_byte
*start
, *insns
, *insns_end
;
700 bfd_size_type length
;
701 unsigned int set_loc_count
;
703 this_inf
= sec_info
->entry
+ sec_info
->count
;
706 /* Read the length of the entry. */
707 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
708 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
710 /* The CIE/FDE must be fully contained in this input section. */
711 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
712 end
= buf
+ hdr_length
;
714 this_inf
->offset
= last_fde
- ehbuf
;
715 this_inf
->size
= 4 + hdr_length
;
716 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
720 /* A zero-length CIE should only be found at the end of
721 the section, but allow multiple terminators. */
722 while (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4))
723 REQUIRE (bfd_get_32 (abfd
, buf
- 4) == 0);
724 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
725 ENSURE_NO_RELOCS (buf
);
730 REQUIRE (skip_bytes (&buf
, end
, 4));
731 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
735 unsigned int initial_insn_length
;
740 /* Point CIE to one of the section-local cie structures. */
741 cie
= local_cies
+ cie_count
++;
743 cie
->cie_inf
= this_inf
;
744 cie
->length
= hdr_length
;
746 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
748 /* Cannot handle unknown versions. */
749 REQUIRE (cie
->version
== 1
751 || cie
->version
== 4);
752 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
754 strcpy (cie
->augmentation
, (char *) buf
);
755 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
756 this_inf
->u
.cie
.aug_str_len
= buf
- start
- 1;
757 ENSURE_NO_RELOCS (buf
);
758 if (buf
[0] == 'e' && buf
[1] == 'h')
760 /* GCC < 3.0 .eh_frame CIE */
761 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
762 is private to each CIE, so we don't need it for anything.
764 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
767 if (cie
->version
>= 4)
769 REQUIRE (buf
+ 1 < end
);
770 REQUIRE (buf
[0] == ptr_size
);
771 REQUIRE (buf
[1] == 0);
774 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
775 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
776 if (cie
->version
== 1)
779 cie
->ra_column
= *buf
++;
782 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
783 ENSURE_NO_RELOCS (buf
);
784 cie
->lsda_encoding
= DW_EH_PE_omit
;
785 cie
->fde_encoding
= DW_EH_PE_omit
;
786 cie
->per_encoding
= DW_EH_PE_omit
;
787 aug
= cie
->augmentation
;
788 if (aug
[0] != 'e' || aug
[1] != 'h')
793 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
794 ENSURE_NO_RELOCS (buf
);
803 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
804 ENSURE_NO_RELOCS (buf
);
805 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
808 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
809 ENSURE_NO_RELOCS (buf
);
810 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
818 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
819 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
822 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
824 length
= -(buf
- ehbuf
) & (per_width
- 1);
825 REQUIRE (skip_bytes (&buf
, end
, length
));
827 this_inf
->u
.cie
.per_encoding_aligned8
= 1;
829 this_inf
->u
.cie
.personality_offset
= buf
- start
;
830 ENSURE_NO_RELOCS (buf
);
831 /* Ensure we have a reloc here. */
832 REQUIRE (GET_RELOC (buf
));
833 cie
->personality
.reloc_index
834 = cookie
->rel
- cookie
->rels
;
835 /* Cope with MIPS-style composite relocations. */
838 while (GET_RELOC (buf
) != NULL
);
839 REQUIRE (skip_bytes (&buf
, end
, per_width
));
843 /* Unrecognized augmentation. Better bail out. */
847 this_inf
->u
.cie
.aug_data_len
848 = buf
- start
- 1 - this_inf
->u
.cie
.aug_str_len
;
850 /* For shared libraries, try to get rid of as many RELATIVE relocs
852 if (bfd_link_pic (info
)
853 && (get_elf_backend_data (abfd
)
854 ->elf_backend_can_make_relative_eh_frame
857 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
858 this_inf
->make_relative
= 1;
859 /* If the CIE doesn't already have an 'R' entry, it's fairly
860 easy to add one, provided that there's no aligned data
861 after the augmentation string. */
862 else if (cie
->fde_encoding
== DW_EH_PE_omit
863 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
865 if (*cie
->augmentation
== 0)
866 this_inf
->add_augmentation_size
= 1;
867 this_inf
->u
.cie
.add_fde_encoding
= 1;
868 this_inf
->make_relative
= 1;
871 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
872 cie
->can_make_lsda_relative
= 1;
875 /* If FDE encoding was not specified, it defaults to
877 if (cie
->fde_encoding
== DW_EH_PE_omit
)
878 cie
->fde_encoding
= DW_EH_PE_absptr
;
880 initial_insn_length
= end
- buf
;
881 cie
->initial_insn_length
= initial_insn_length
;
882 memcpy (cie
->initial_instructions
, buf
,
883 initial_insn_length
<= sizeof (cie
->initial_instructions
)
884 ? initial_insn_length
: sizeof (cie
->initial_instructions
));
886 buf
+= initial_insn_length
;
887 ENSURE_NO_RELOCS (buf
);
889 if (!bfd_link_relocatable (info
))
891 /* Keep info for merging cies. */
892 this_inf
->u
.cie
.u
.full_cie
= cie
;
893 this_inf
->u
.cie
.per_encoding_relative
894 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
899 /* Find the corresponding CIE. */
900 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
901 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
902 if (cie_offset
== cie
->cie_inf
->offset
)
905 /* Ensure this FDE references one of the CIEs in this input
907 REQUIRE (cie
!= local_cies
+ cie_count
);
908 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
909 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
910 this_inf
->add_augmentation_size
911 = cie
->cie_inf
->add_augmentation_size
;
913 ENSURE_NO_RELOCS (buf
);
914 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
918 REQUIRE (GET_RELOC (buf
));
920 /* Chain together the FDEs for each section. */
921 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
,
923 /* RSEC will be NULL if FDE was cleared out as it was belonging to
924 a discarded SHT_GROUP. */
927 REQUIRE (rsec
->owner
== abfd
);
928 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
929 elf_fde_list (rsec
) = this_inf
;
933 /* Skip the initial location and address range. */
935 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
936 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
938 SKIP_RELOCS (buf
- length
);
939 if (!GET_RELOC (buf
- length
)
940 && read_value (abfd
, buf
- length
, length
, false) == 0)
942 (*info
->callbacks
->minfo
)
943 /* xgettext:c-format */
944 (_("discarding zero address range FDE in %pB(%pA).\n"),
946 this_inf
->u
.fde
.cie_inf
= NULL
;
949 /* Skip the augmentation size, if present. */
950 if (cie
->augmentation
[0] == 'z')
951 REQUIRE (read_uleb128 (&buf
, end
, &length
));
955 /* Of the supported augmentation characters above, only 'L'
956 adds augmentation data to the FDE. This code would need to
957 be adjusted if any future augmentations do the same thing. */
958 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
961 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
962 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
963 this_inf
->lsda_offset
= buf
- start
;
964 /* If there's no 'z' augmentation, we don't know where the
965 CFA insns begin. Assume no padding. */
966 if (cie
->augmentation
[0] != 'z')
970 /* Skip over the augmentation data. */
971 REQUIRE (skip_bytes (&buf
, end
, length
));
974 buf
= last_fde
+ 4 + hdr_length
;
976 /* For NULL RSEC (cleared FDE belonging to a discarded section)
977 the relocations are commonly cleared. We do not sanity check if
978 all these relocations are cleared as (1) relocations to
979 .gcc_except_table will remain uncleared (they will get dropped
980 with the drop of this unused FDE) and (2) BFD already safely drops
981 relocations of any type to .eh_frame by
982 elf_section_ignore_discarded_relocs.
983 TODO: The .gcc_except_table entries should be also filtered as
984 .eh_frame entries; or GCC could rather use COMDAT for them. */
988 /* Try to interpret the CFA instructions and find the first
989 padding nop. Shrink this_inf's size so that it doesn't
990 include the padding. */
991 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
993 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
994 /* If we don't understand the CFA instructions, we can't know
995 what needs to be adjusted there. */
996 if (insns_end
== NULL
997 /* For the time being we don't support DW_CFA_set_loc in
999 || (set_loc_count
&& this_inf
->cie
))
1001 this_inf
->size
-= end
- insns_end
;
1002 if (insns_end
!= end
&& this_inf
->cie
)
1004 cie
->initial_insn_length
-= end
- insns_end
;
1005 cie
->length
-= end
- insns_end
;
1008 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
1009 || this_inf
->make_relative
))
1014 this_inf
->set_loc
= (unsigned int *)
1015 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
1016 REQUIRE (this_inf
->set_loc
);
1017 this_inf
->set_loc
[0] = set_loc_count
;
1022 if (*p
== DW_CFA_set_loc
)
1023 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
1024 REQUIRE (skip_cfa_op (&p
, end
, length
));
1028 this_inf
->removed
= 1;
1029 this_inf
->fde_encoding
= cie
->fde_encoding
;
1030 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
1033 BFD_ASSERT (sec_info
->count
== num_entries
);
1034 BFD_ASSERT (cie_count
== num_cies
);
1036 elf_section_data (sec
)->sec_info
= sec_info
;
1037 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
1038 if (!bfd_link_relocatable (info
))
1040 /* Keep info for merging cies. */
1041 sec_info
->cies
= local_cies
;
1048 /* xgettext:c-format */
1049 (_("error in %pB(%pA); no .eh_frame_hdr table will be created"),
1051 hdr_info
->u
.dwarf
.table
= false;
1059 /* Order eh_frame_hdr entries by the VMA of their text section. */
1062 cmp_eh_frame_hdr (const void *a
, const void *b
)
1068 sec
= *(asection
*const *)a
;
1069 sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1070 text_a
= sec
->output_section
->vma
+ sec
->output_offset
;
1071 sec
= *(asection
*const *)b
;
1072 sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1073 text_b
= sec
->output_section
->vma
+ sec
->output_offset
;
1075 if (text_a
< text_b
)
1077 return text_a
> text_b
;
1081 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1082 referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1085 add_eh_frame_hdr_terminator (asection
*sec
,
1094 /* See if there is a gap (presumably a text section without unwind info)
1095 between these two entries. */
1096 text_sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1097 end
= text_sec
->output_section
->vma
+ text_sec
->output_offset
1099 text_sec
= (asection
*) elf_section_data (next
)->sec_info
;
1100 next_start
= text_sec
->output_section
->vma
+ text_sec
->output_offset
;
1101 if (end
== next_start
)
1105 /* Add space for a CANTUNWIND terminator. */
1107 sec
->rawsize
= sec
->size
;
1109 bfd_set_section_size (sec
, sec
->size
+ 8);
1112 /* Finish a pass over all .eh_frame_entry sections. */
1115 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
1117 struct eh_frame_hdr_info
*hdr_info
;
1120 hdr_info
= &elf_hash_table (info
)->eh_info
;
1122 if (info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
1123 || hdr_info
->array_count
== 0)
1126 bfd_elf_discard_eh_frame_entry (hdr_info
);
1128 qsort (hdr_info
->u
.compact
.entries
, hdr_info
->array_count
,
1129 sizeof (asection
*), cmp_eh_frame_hdr
);
1131 for (i
= 0; i
< hdr_info
->array_count
- 1; i
++)
1133 add_eh_frame_hdr_terminator (hdr_info
->u
.compact
.entries
[i
],
1134 hdr_info
->u
.compact
.entries
[i
+ 1]);
1137 /* Add a CANTUNWIND terminator after the last entry. */
1138 add_eh_frame_hdr_terminator (hdr_info
->u
.compact
.entries
[i
], NULL
);
1142 /* Mark all relocations against CIE or FDE ENT, which occurs in
1143 .eh_frame section SEC. COOKIE describes the relocations in SEC;
1144 its "rel" field can be changed freely. */
1147 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
1148 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
1149 struct elf_reloc_cookie
*cookie
)
1151 /* FIXME: octets_per_byte. */
1152 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1153 cookie
->rel
< cookie
->relend
1154 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
1156 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
1162 /* Mark all the relocations against FDEs that relate to code in input
1163 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1164 relocations are described by COOKIE. */
1167 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
1168 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
1169 struct elf_reloc_cookie
*cookie
)
1171 struct eh_cie_fde
*fde
, *cie
;
1173 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
1175 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
1178 /* At this stage, all cie_inf fields point to local CIEs, so we
1179 can use the same cookie to refer to them. */
1180 cie
= fde
->u
.fde
.cie_inf
;
1181 if (cie
!= NULL
&& !cie
->u
.cie
.gc_mark
)
1183 cie
->u
.cie
.gc_mark
= 1;
1184 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
1191 /* Input section SEC of ABFD is an .eh_frame section that contains the
1192 CIE described by CIE_INF. Return a version of CIE_INF that is going
1193 to be kept in the output, adding CIE_INF to the output if necessary.
1195 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1196 relocations in REL. */
1198 static struct eh_cie_fde
*
1199 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1200 struct eh_frame_hdr_info
*hdr_info
,
1201 struct elf_reloc_cookie
*cookie
,
1202 struct eh_cie_fde
*cie_inf
)
1204 unsigned long r_symndx
;
1205 struct cie
*cie
, *new_cie
;
1206 Elf_Internal_Rela
*rel
;
1209 /* Use CIE_INF if we have already decided to keep it. */
1210 if (!cie_inf
->removed
)
1213 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1214 if (cie_inf
->u
.cie
.merged
)
1215 return cie_inf
->u
.cie
.u
.merged_with
;
1217 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1219 /* Assume we will need to keep CIE_INF. */
1220 cie_inf
->removed
= 0;
1221 cie_inf
->u
.cie
.u
.sec
= sec
;
1223 /* If we are not merging CIEs, use CIE_INF. */
1227 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1229 bool per_binds_local
;
1231 /* Work out the address of personality routine, or at least
1232 enough info that we could calculate the address had we made a
1233 final section layout. The symbol on the reloc is enough,
1234 either the hash for a global, or (bfd id, index) pair for a
1235 local. The assumption here is that no one uses addends on
1237 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1238 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1240 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1241 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1244 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1245 if (r_symndx
>= cookie
->locsymcount
1246 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1248 struct elf_link_hash_entry
*h
;
1250 r_symndx
-= cookie
->extsymoff
;
1251 h
= cookie
->sym_hashes
[r_symndx
];
1253 while (h
->root
.type
== bfd_link_hash_indirect
1254 || h
->root
.type
== bfd_link_hash_warning
)
1255 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1257 cie
->personality
.h
= h
;
1258 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1262 Elf_Internal_Sym
*sym
;
1265 sym
= &cookie
->locsyms
[r_symndx
];
1266 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1267 if (sym_sec
== NULL
)
1270 if (sym_sec
->kept_section
!= NULL
)
1271 sym_sec
= sym_sec
->kept_section
;
1272 if (sym_sec
->output_section
== NULL
)
1275 cie
->local_personality
= 1;
1276 cie
->personality
.sym
.bfd_id
= abfd
->id
;
1277 cie
->personality
.sym
.index
= r_symndx
;
1278 per_binds_local
= true;
1282 && bfd_link_pic (info
)
1283 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1284 && (get_elf_backend_data (abfd
)
1285 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1287 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1288 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1292 /* See if we can merge this CIE with an earlier one. */
1293 cie_compute_hash (cie
);
1294 if (hdr_info
->u
.dwarf
.cies
== NULL
)
1296 hdr_info
->u
.dwarf
.cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1297 if (hdr_info
->u
.dwarf
.cies
== NULL
)
1300 loc
= htab_find_slot_with_hash (hdr_info
->u
.dwarf
.cies
, cie
,
1305 new_cie
= (struct cie
*) *loc
;
1306 if (new_cie
== NULL
)
1308 /* Keep CIE_INF and record it in the hash table. */
1309 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1310 if (new_cie
== NULL
)
1313 memcpy (new_cie
, cie
, sizeof (struct cie
));
1318 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1319 cie_inf
->removed
= 1;
1320 cie_inf
->u
.cie
.merged
= 1;
1321 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1322 if (cie_inf
->u
.cie
.make_lsda_relative
)
1323 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1325 return new_cie
->cie_inf
;
1328 /* For a given OFFSET in SEC, return the delta to the new location
1329 after .eh_frame editing. */
1331 static bfd_signed_vma
1332 offset_adjust (bfd_vma offset
, const asection
*sec
)
1334 struct eh_frame_sec_info
*sec_info
1335 = (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1336 unsigned int lo
, hi
, mid
;
1337 struct eh_cie_fde
*ent
= NULL
;
1338 bfd_signed_vma delta
;
1341 hi
= sec_info
->count
;
1347 mid
= (lo
+ hi
) / 2;
1348 ent
= &sec_info
->entry
[mid
];
1349 if (offset
< ent
->offset
)
1351 else if (mid
+ 1 >= hi
)
1353 else if (offset
>= ent
[1].offset
)
1360 delta
= (bfd_vma
) ent
->new_offset
- (bfd_vma
) ent
->offset
;
1361 else if (ent
->cie
&& ent
->u
.cie
.merged
)
1363 struct eh_cie_fde
*cie
= ent
->u
.cie
.u
.merged_with
;
1364 delta
= ((bfd_vma
) cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
1365 - (bfd_vma
) ent
->offset
- sec
->output_offset
);
1369 /* Is putting the symbol on the next entry best for a deleted
1371 struct eh_cie_fde
*last
= sec_info
->entry
+ sec_info
->count
;
1372 delta
= ((bfd_vma
) next_cie_fde_offset (ent
, last
, sec
)
1373 - (bfd_vma
) ent
->offset
);
1377 /* Account for editing within this CIE/FDE. */
1378 offset
-= ent
->offset
;
1382 = ent
->add_augmentation_size
+ ent
->u
.cie
.add_fde_encoding
;
1384 || offset
<= 9u + ent
->u
.cie
.aug_str_len
)
1387 if (offset
<= 9u + ent
->u
.cie
.aug_str_len
+ ent
->u
.cie
.aug_data_len
)
1393 unsigned int ptr_size
, width
, extra
= ent
->add_augmentation_size
;
1394 if (offset
<= 12 || extra
== 0)
1396 ptr_size
= (get_elf_backend_data (sec
->owner
)
1397 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1398 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1399 if (offset
<= 8 + 2 * width
)
1407 /* Adjust a global symbol defined in .eh_frame, so that it stays
1408 relative to its original CIE/FDE. It is assumed that a symbol
1409 defined at the beginning of a CIE/FDE belongs to that CIE/FDE
1410 rather than marking the end of the previous CIE/FDE. This matters
1411 when a CIE is merged with a previous CIE, since the symbol is
1412 moved to the merged CIE. */
1415 _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry
*h
,
1416 void *arg ATTRIBUTE_UNUSED
)
1419 bfd_signed_vma delta
;
1421 if (h
->root
.type
!= bfd_link_hash_defined
1422 && h
->root
.type
!= bfd_link_hash_defweak
)
1425 sym_sec
= h
->root
.u
.def
.section
;
1426 if (sym_sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
1427 || elf_section_data (sym_sec
)->sec_info
== NULL
)
1430 delta
= offset_adjust (h
->root
.u
.def
.value
, sym_sec
);
1431 h
->root
.u
.def
.value
+= delta
;
1436 /* The same for all local symbols defined in .eh_frame. Returns true
1437 if any symbol was changed. */
1440 adjust_eh_frame_local_symbols (const asection
*sec
,
1441 struct elf_reloc_cookie
*cookie
)
1445 if (cookie
->locsymcount
> 1)
1447 unsigned int shndx
= elf_section_data (sec
)->this_idx
;
1448 Elf_Internal_Sym
*end_sym
= cookie
->locsyms
+ cookie
->locsymcount
;
1449 Elf_Internal_Sym
*sym
;
1451 for (sym
= cookie
->locsyms
+ 1; sym
< end_sym
; ++sym
)
1452 if (sym
->st_info
<= ELF_ST_INFO (STB_LOCAL
, STT_OBJECT
)
1453 && sym
->st_shndx
== shndx
)
1455 bfd_signed_vma delta
= offset_adjust (sym
->st_value
, sec
);
1460 sym
->st_value
+= delta
;
1467 /* This function is called for each input file before the .eh_frame
1468 section is relocated. It discards duplicate CIEs and FDEs for discarded
1469 functions. The function returns TRUE iff any entries have been
1473 _bfd_elf_discard_section_eh_frame
1474 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1475 bool (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1476 struct elf_reloc_cookie
*cookie
)
1478 struct eh_cie_fde
*ent
;
1479 struct eh_frame_sec_info
*sec_info
;
1480 struct eh_frame_hdr_info
*hdr_info
;
1481 unsigned int ptr_size
, offset
, eh_alignment
;
1484 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1487 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1488 if (sec_info
== NULL
)
1491 ptr_size
= (get_elf_backend_data (sec
->owner
)
1492 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1494 hdr_info
= &elf_hash_table (info
)->eh_info
;
1495 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1497 /* There should only be one zero terminator, on the last input
1498 file supplying .eh_frame (crtend.o). Remove any others. */
1499 ent
->removed
= sec
->map_head
.s
!= NULL
;
1500 else if (!ent
->cie
&& ent
->u
.fde
.cie_inf
!= NULL
)
1503 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1506 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1508 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1509 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1514 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1515 /* FIXME: octets_per_byte. */
1516 BFD_ASSERT (cookie
->rel
< cookie
->relend
1517 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1518 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1522 if (bfd_link_pic (info
)
1523 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1524 && ent
->make_relative
== 0)
1525 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1527 static int num_warnings_issued
= 0;
1529 /* If a shared library uses absolute pointers
1530 which we cannot turn into PC relative,
1531 don't create the binary search table,
1532 since it is affected by runtime relocations. */
1533 hdr_info
->u
.dwarf
.table
= false;
1534 /* Only warn if --eh-frame-hdr was specified. */
1535 if (info
->eh_frame_hdr_type
!= 0)
1537 if (num_warnings_issued
< 10)
1540 /* xgettext:c-format */
1541 (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr"
1542 " table being created"), abfd
, sec
);
1543 num_warnings_issued
++;
1545 else if (num_warnings_issued
== 10)
1548 (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped"));
1549 num_warnings_issued
++;
1554 hdr_info
->u
.dwarf
.fde_count
++;
1555 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1556 cookie
, ent
->u
.fde
.cie_inf
);
1560 free (sec_info
->cies
);
1561 sec_info
->cies
= NULL
;
1563 /* It may be that some .eh_frame input section has greater alignment
1564 than other .eh_frame sections. In that case we run the risk of
1565 padding with zeros before that section, which would be seen as a
1566 zero terminator. Alignment padding must be added *inside* the
1567 last FDE instead. For other FDEs we align according to their
1568 encoding, in order to align FDE address range entries naturally. */
1571 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1579 if (ent
->u
.cie
.per_encoding_aligned8
)
1584 eh_alignment
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1585 if (eh_alignment
< 4)
1588 offset
= (offset
+ eh_alignment
- 1) & -eh_alignment
;
1589 ent
->new_offset
= offset
;
1590 if (ent
->new_offset
!= ent
->offset
)
1592 offset
+= size_of_output_cie_fde (ent
);
1596 offset
= (offset
+ eh_alignment
- 1) & -eh_alignment
;
1597 sec
->rawsize
= sec
->size
;
1599 if (sec
->size
!= sec
->rawsize
)
1602 if (changed
&& adjust_eh_frame_local_symbols (sec
, cookie
))
1604 Elf_Internal_Shdr
*symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1605 symtab_hdr
->contents
= (unsigned char *) cookie
->locsyms
;
1610 /* This function is called for .eh_frame_hdr section after
1611 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1612 input sections. It finalizes the size of .eh_frame_hdr section. */
1615 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1617 struct elf_link_hash_table
*htab
;
1618 struct eh_frame_hdr_info
*hdr_info
;
1621 htab
= elf_hash_table (info
);
1622 hdr_info
= &htab
->eh_info
;
1624 if (!hdr_info
->frame_hdr_is_compact
&& hdr_info
->u
.dwarf
.cies
!= NULL
)
1626 htab_delete (hdr_info
->u
.dwarf
.cies
);
1627 hdr_info
->u
.dwarf
.cies
= NULL
;
1630 sec
= hdr_info
->hdr_sec
;
1634 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
1636 /* For compact frames we only add the header. The actual table comes
1637 from the .eh_frame_entry sections. */
1642 sec
->size
= EH_FRAME_HDR_SIZE
;
1643 if (hdr_info
->u
.dwarf
.table
)
1644 sec
->size
+= 4 + hdr_info
->u
.dwarf
.fde_count
* 8;
1647 elf_eh_frame_hdr (abfd
) = sec
;
1651 /* Return true if there is at least one non-empty .eh_frame section in
1652 input files. Can only be called after ld has mapped input to
1653 output sections, and before sections are stripped. */
1656 _bfd_elf_eh_frame_present (struct bfd_link_info
*info
)
1658 asection
*eh
= bfd_get_section_by_name (info
->output_bfd
, ".eh_frame");
1663 /* Count only sections which have at least a single CIE or FDE.
1664 There cannot be any CIE or FDE <= 8 bytes. */
1665 for (eh
= eh
->map_head
.s
; eh
!= NULL
; eh
= eh
->map_head
.s
)
1672 /* Return true if there is at least one .eh_frame_entry section in
1676 _bfd_elf_eh_frame_entry_present (struct bfd_link_info
*info
)
1681 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1683 for (o
= abfd
->sections
; o
; o
= o
->next
)
1685 const char *name
= bfd_section_name (o
);
1687 if (strcmp (name
, ".eh_frame_entry")
1688 && !bfd_is_abs_section (o
->output_section
))
1695 /* This function is called from size_dynamic_sections.
1696 It needs to decide whether .eh_frame_hdr should be output or not,
1697 because when the dynamic symbol table has been sized it is too late
1698 to strip sections. */
1701 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1703 struct elf_link_hash_table
*htab
;
1704 struct eh_frame_hdr_info
*hdr_info
;
1705 struct bfd_link_hash_entry
*bh
= NULL
;
1706 struct elf_link_hash_entry
*h
;
1708 htab
= elf_hash_table (info
);
1709 hdr_info
= &htab
->eh_info
;
1710 if (hdr_info
->hdr_sec
== NULL
)
1713 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
)
1714 || info
->eh_frame_hdr_type
== 0
1715 || (info
->eh_frame_hdr_type
== DWARF2_EH_HDR
1716 && !_bfd_elf_eh_frame_present (info
))
1717 || (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
1718 && !_bfd_elf_eh_frame_entry_present (info
)))
1720 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1721 hdr_info
->hdr_sec
= NULL
;
1725 /* Add a hidden symbol so that systems without access to PHDRs can
1727 if (! (_bfd_generic_link_add_one_symbol
1728 (info
, info
->output_bfd
, "__GNU_EH_FRAME_HDR", BSF_LOCAL
,
1729 hdr_info
->hdr_sec
, 0, NULL
, false, false, &bh
)))
1732 h
= (struct elf_link_hash_entry
*) bh
;
1734 h
->other
= STV_HIDDEN
;
1735 get_elf_backend_data
1736 (info
->output_bfd
)->elf_backend_hide_symbol (info
, h
, true);
1738 if (!hdr_info
->frame_hdr_is_compact
)
1739 hdr_info
->u
.dwarf
.table
= true;
1743 /* Adjust an address in the .eh_frame section. Given OFFSET within
1744 SEC, this returns the new offset in the adjusted .eh_frame section,
1745 or -1 if the address refers to a CIE/FDE which has been removed
1746 or to offset with dynamic relocation which is no longer needed. */
1749 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1750 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1754 struct eh_frame_sec_info
*sec_info
;
1755 unsigned int lo
, hi
, mid
;
1757 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1759 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1761 if (offset
>= sec
->rawsize
)
1762 return offset
- sec
->rawsize
+ sec
->size
;
1765 hi
= sec_info
->count
;
1769 mid
= (lo
+ hi
) / 2;
1770 if (offset
< sec_info
->entry
[mid
].offset
)
1773 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1779 BFD_ASSERT (lo
< hi
);
1781 /* FDE or CIE was removed. */
1782 if (sec_info
->entry
[mid
].removed
)
1783 return (bfd_vma
) -1;
1785 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1786 no need for run-time relocation against the personality field. */
1787 if (sec_info
->entry
[mid
].cie
1788 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1789 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1790 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1791 return (bfd_vma
) -2;
1793 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1794 relocation against FDE's initial_location field. */
1795 if (!sec_info
->entry
[mid
].cie
1796 && sec_info
->entry
[mid
].make_relative
1797 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1798 return (bfd_vma
) -2;
1800 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1801 for run-time relocation against LSDA field. */
1802 if (!sec_info
->entry
[mid
].cie
1803 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1804 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1805 + sec_info
->entry
[mid
].lsda_offset
))
1806 return (bfd_vma
) -2;
1808 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1809 relocation against DW_CFA_set_loc's arguments. */
1810 if (sec_info
->entry
[mid
].set_loc
1811 && sec_info
->entry
[mid
].make_relative
1812 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1813 + sec_info
->entry
[mid
].set_loc
[1]))
1817 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1818 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1819 + sec_info
->entry
[mid
].set_loc
[cnt
])
1820 return (bfd_vma
) -2;
1823 /* Any new augmentation bytes go before the first relocation. */
1824 return (offset
+ sec_info
->entry
[mid
].new_offset
1825 - sec_info
->entry
[mid
].offset
1826 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1827 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1830 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1831 Also check that the contents look sane. */
1834 _bfd_elf_write_section_eh_frame_entry (bfd
*abfd
, struct bfd_link_info
*info
,
1835 asection
*sec
, bfd_byte
*contents
)
1837 const struct elf_backend_data
*bed
;
1838 bfd_byte cantunwind
[8];
1842 asection
*text_sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1845 sec
->rawsize
= sec
->size
;
1847 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME_ENTRY
);
1849 /* Check to make sure that the text section corresponding to this eh_frame_entry
1850 section has not been excluded. In particular, mips16 stub entries will be
1851 excluded outside of the normal process. */
1852 if (sec
->flags
& SEC_EXCLUDE
1853 || text_sec
->flags
& SEC_EXCLUDE
)
1856 if (!bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1857 sec
->output_offset
, sec
->rawsize
))
1860 last_addr
= bfd_get_signed_32 (abfd
, contents
);
1861 /* Check that all the entries are in order. */
1862 for (offset
= 8; offset
< sec
->rawsize
; offset
+= 8)
1864 addr
= bfd_get_signed_32 (abfd
, contents
+ offset
) + offset
;
1865 if (addr
<= last_addr
)
1867 /* xgettext:c-format */
1868 _bfd_error_handler (_("%pB: %pA not in order"), sec
->owner
, sec
);
1875 addr
= text_sec
->output_section
->vma
+ text_sec
->output_offset
1878 addr
-= (sec
->output_section
->vma
+ sec
->output_offset
+ sec
->rawsize
);
1881 /* xgettext:c-format */
1882 _bfd_error_handler (_("%pB: %pA invalid input section size"),
1884 bfd_set_error (bfd_error_bad_value
);
1887 if (last_addr
>= addr
+ sec
->rawsize
)
1889 /* xgettext:c-format */
1890 _bfd_error_handler (_("%pB: %pA points past end of text section"),
1892 bfd_set_error (bfd_error_bad_value
);
1896 if (sec
->size
== sec
->rawsize
)
1899 bed
= get_elf_backend_data (abfd
);
1900 BFD_ASSERT (sec
->size
== sec
->rawsize
+ 8);
1901 BFD_ASSERT ((addr
& 1) == 0);
1902 BFD_ASSERT (bed
->cant_unwind_opcode
);
1904 bfd_put_32 (abfd
, addr
, cantunwind
);
1905 bfd_put_32 (abfd
, (*bed
->cant_unwind_opcode
) (info
), cantunwind
+ 4);
1906 return bfd_set_section_contents (abfd
, sec
->output_section
, cantunwind
,
1907 sec
->output_offset
+ sec
->rawsize
, 8);
1910 /* Write out .eh_frame section. This is called with the relocated
1914 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1915 struct bfd_link_info
*info
,
1919 struct eh_frame_sec_info
*sec_info
;
1920 struct elf_link_hash_table
*htab
;
1921 struct eh_frame_hdr_info
*hdr_info
;
1922 unsigned int ptr_size
;
1923 struct eh_cie_fde
*ent
, *last_ent
;
1925 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1926 /* FIXME: octets_per_byte. */
1927 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1928 sec
->output_offset
, sec
->size
);
1930 ptr_size
= (get_elf_backend_data (abfd
)
1931 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1932 BFD_ASSERT (ptr_size
!= 0);
1934 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1935 htab
= elf_hash_table (info
);
1936 hdr_info
= &htab
->eh_info
;
1938 if (hdr_info
->u
.dwarf
.table
&& hdr_info
->u
.dwarf
.array
== NULL
)
1940 hdr_info
->frame_hdr_is_compact
= false;
1941 hdr_info
->u
.dwarf
.array
= (struct eh_frame_array_ent
*)
1942 bfd_malloc (hdr_info
->u
.dwarf
.fde_count
1943 * sizeof (*hdr_info
->u
.dwarf
.array
));
1945 if (hdr_info
->u
.dwarf
.array
== NULL
)
1948 /* The new offsets can be bigger or smaller than the original offsets.
1949 We therefore need to make two passes over the section: one backward
1950 pass to move entries up and one forward pass to move entries down.
1951 The two passes won't interfere with each other because entries are
1953 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1954 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1955 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1957 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1958 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1959 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1961 last_ent
= sec_info
->entry
+ sec_info
->count
;
1962 for (ent
= sec_info
->entry
; ent
< last_ent
; ++ent
)
1964 unsigned char *buf
, *end
;
1965 unsigned int new_size
;
1972 /* Any terminating FDE must be at the end of the section. */
1973 BFD_ASSERT (ent
== last_ent
- 1);
1977 buf
= contents
+ ent
->new_offset
;
1978 end
= buf
+ ent
->size
;
1979 new_size
= next_cie_fde_offset (ent
, last_ent
, sec
) - ent
->new_offset
;
1981 /* Update the size. It may be shrinked. */
1982 bfd_put_32 (abfd
, new_size
- 4, buf
);
1984 /* Filling the extra bytes with DW_CFA_nops. */
1985 if (new_size
!= ent
->size
)
1986 memset (end
, 0, new_size
- ent
->size
);
1991 if (ent
->make_relative
1992 || ent
->u
.cie
.make_lsda_relative
1993 || ent
->u
.cie
.per_encoding_relative
)
1996 unsigned int version
, action
, extra_string
, extra_data
;
1997 unsigned int per_width
, per_encoding
;
1999 /* Need to find 'R' or 'L' augmentation's argument and modify
2000 DW_EH_PE_* value. */
2001 action
= ((ent
->make_relative
? 1 : 0)
2002 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
2003 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
2004 extra_string
= extra_augmentation_string_bytes (ent
);
2005 extra_data
= extra_augmentation_data_bytes (ent
);
2007 /* Skip length, id. */
2011 buf
+= strlen (aug
) + 1;
2012 skip_leb128 (&buf
, end
);
2013 skip_leb128 (&buf
, end
);
2015 skip_bytes (&buf
, end
, 1);
2017 skip_leb128 (&buf
, end
);
2020 /* The uleb128 will always be a single byte for the kind
2021 of augmentation strings that we're prepared to handle. */
2022 *buf
++ += extra_data
;
2026 /* Make room for the new augmentation string and data bytes. */
2027 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
2028 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
2029 buf
+= extra_string
;
2030 end
+= extra_string
+ extra_data
;
2032 if (ent
->add_augmentation_size
)
2035 *buf
++ = extra_data
- 1;
2037 if (ent
->u
.cie
.add_fde_encoding
)
2039 BFD_ASSERT (action
& 1);
2041 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
2051 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
2052 *buf
= make_pc_relative (*buf
, ptr_size
);
2058 if (ent
->u
.cie
.make_per_encoding_relative
)
2059 *buf
= make_pc_relative (*buf
, ptr_size
);
2060 per_encoding
= *buf
++;
2061 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
2062 BFD_ASSERT (per_width
!= 0);
2063 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
2064 == ent
->u
.cie
.per_encoding_relative
);
2065 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
2067 + ((buf
- contents
+ per_width
- 1)
2068 & ~((bfd_size_type
) per_width
- 1)));
2073 val
= read_value (abfd
, buf
, per_width
,
2074 get_DW_EH_PE_signed (per_encoding
));
2075 if (ent
->u
.cie
.make_per_encoding_relative
)
2076 val
-= (sec
->output_section
->vma
2077 + sec
->output_offset
2078 + (buf
- contents
));
2081 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
2082 val
-= extra_string
+ extra_data
;
2084 write_value (abfd
, buf
, val
, per_width
);
2092 BFD_ASSERT (*buf
== ent
->fde_encoding
);
2093 *buf
= make_pc_relative (*buf
, ptr_size
);
2108 bfd_vma value
, address
;
2111 struct eh_cie_fde
*cie
;
2114 cie
= ent
->u
.fde
.cie_inf
;
2116 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
2117 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
2118 bfd_put_32 (abfd
, value
, buf
);
2119 if (bfd_link_relocatable (info
))
2122 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
2123 value
= read_value (abfd
, buf
, width
,
2124 get_DW_EH_PE_signed (ent
->fde_encoding
));
2128 switch (ent
->fde_encoding
& 0x70)
2130 case DW_EH_PE_textrel
:
2131 BFD_ASSERT (hdr_info
== NULL
);
2133 case DW_EH_PE_datarel
:
2135 switch (abfd
->arch_info
->arch
)
2138 BFD_ASSERT (elf_gp (abfd
) != 0);
2139 address
+= elf_gp (abfd
);
2143 (_("DW_EH_PE_datarel unspecified"
2144 " for this architecture"));
2148 case bfd_arch_nios2
:
2149 BFD_ASSERT (htab
->hgot
!= NULL
2150 && ((htab
->hgot
->root
.type
2151 == bfd_link_hash_defined
)
2152 || (htab
->hgot
->root
.type
2153 == bfd_link_hash_defweak
)));
2155 += (htab
->hgot
->root
.u
.def
.value
2156 + htab
->hgot
->root
.u
.def
.section
->output_offset
2157 + (htab
->hgot
->root
.u
.def
.section
->output_section
2163 case DW_EH_PE_pcrel
:
2164 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
2165 address
+= (sec
->output_section
->vma
2166 + sec
->output_offset
2170 if (ent
->make_relative
)
2171 value
-= (sec
->output_section
->vma
2172 + sec
->output_offset
2173 + ent
->new_offset
+ 8);
2174 write_value (abfd
, buf
, value
, width
);
2181 /* The address calculation may overflow, giving us a
2182 value greater than 4G on a 32-bit target when
2183 dwarf_vma is 64-bit. */
2184 if (sizeof (address
) > 4 && ptr_size
== 4)
2185 address
&= 0xffffffff;
2186 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
].initial_loc
2188 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
].range
2189 = read_value (abfd
, buf
+ width
, width
, false);
2190 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
++].fde
2191 = (sec
->output_section
->vma
2192 + sec
->output_offset
2196 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
2197 || cie
->u
.cie
.make_lsda_relative
)
2199 buf
+= ent
->lsda_offset
;
2200 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
2201 value
= read_value (abfd
, buf
, width
,
2202 get_DW_EH_PE_signed (ent
->lsda_encoding
));
2205 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
2206 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
2207 else if (cie
->u
.cie
.make_lsda_relative
)
2208 value
-= (sec
->output_section
->vma
2209 + sec
->output_offset
2210 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
2211 write_value (abfd
, buf
, value
, width
);
2214 else if (ent
->add_augmentation_size
)
2216 /* Skip the PC and length and insert a zero byte for the
2217 augmentation size. */
2219 memmove (buf
+ 1, buf
, end
- buf
);
2225 /* Adjust DW_CFA_set_loc. */
2229 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
2230 new_offset
= ent
->new_offset
+ 8
2231 + extra_augmentation_string_bytes (ent
)
2232 + extra_augmentation_data_bytes (ent
);
2234 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
2236 buf
= start
+ ent
->set_loc
[cnt
];
2238 value
= read_value (abfd
, buf
, width
,
2239 get_DW_EH_PE_signed (ent
->fde_encoding
));
2243 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
2244 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
2245 if (ent
->make_relative
)
2246 value
-= (sec
->output_section
->vma
2247 + sec
->output_offset
2248 + new_offset
+ ent
->set_loc
[cnt
]);
2249 write_value (abfd
, buf
, value
, width
);
2255 /* FIXME: octets_per_byte. */
2256 return bfd_set_section_contents (abfd
, sec
->output_section
,
2257 contents
, (file_ptr
) sec
->output_offset
,
2261 /* Helper function used to sort .eh_frame_hdr search table by increasing
2262 VMA of FDE initial location. */
2265 vma_compare (const void *a
, const void *b
)
2267 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
2268 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
2269 if (p
->initial_loc
> q
->initial_loc
)
2271 if (p
->initial_loc
< q
->initial_loc
)
2273 if (p
->range
> q
->range
)
2275 if (p
->range
< q
->range
)
2280 /* Reorder .eh_frame_entry sections to match the associated text sections.
2281 This routine is called during the final linking step, just before writing
2282 the contents. At this stage, sections in the eh_frame_hdr_info are already
2283 sorted in order of increasing text section address and so we simply need
2284 to make the .eh_frame_entrys follow that same order. Note that it is
2285 invalid for a linker script to try to force a particular order of
2286 .eh_frame_entry sections. */
2289 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info
*info
)
2291 asection
*sec
= NULL
;
2293 struct eh_frame_hdr_info
*hdr_info
;
2296 struct bfd_link_order
*p
;
2298 hdr_info
= &elf_hash_table (info
)->eh_info
;
2300 if (hdr_info
->hdr_sec
== NULL
2301 || info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
2302 || hdr_info
->array_count
== 0)
2305 /* Change section output offsets to be in text section order. */
2307 osec
= hdr_info
->u
.compact
.entries
[0]->output_section
;
2308 for (i
= 0; i
< hdr_info
->array_count
; i
++)
2310 sec
= hdr_info
->u
.compact
.entries
[i
];
2311 if (sec
->output_section
!= osec
)
2314 (_("invalid output section for .eh_frame_entry: %pA"),
2315 sec
->output_section
);
2318 sec
->output_offset
= offset
;
2319 offset
+= sec
->size
;
2323 /* Fix the link_order to match. */
2324 for (p
= sec
->output_section
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
2326 if (p
->type
!= bfd_indirect_link_order
)
2329 p
->offset
= p
->u
.indirect
.section
->output_offset
;
2330 if (p
->next
!= NULL
)
2337 (_("invalid contents in %pA section"), osec
);
2344 /* The .eh_frame_hdr format for Compact EH frames:
2346 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2347 uint32_t count (Number of entries in table)
2348 [array from .eh_frame_entry sections] */
2351 write_compact_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2353 struct elf_link_hash_table
*htab
;
2354 struct eh_frame_hdr_info
*hdr_info
;
2356 const struct elf_backend_data
*bed
;
2358 bfd_byte contents
[8];
2361 htab
= elf_hash_table (info
);
2362 hdr_info
= &htab
->eh_info
;
2363 sec
= hdr_info
->hdr_sec
;
2368 for (i
= 0; i
< sizeof (contents
); i
++)
2371 contents
[0] = COMPACT_EH_HDR
;
2372 bed
= get_elf_backend_data (abfd
);
2374 BFD_ASSERT (bed
->compact_eh_encoding
);
2375 contents
[1] = (*bed
->compact_eh_encoding
) (info
);
2377 count
= (sec
->output_section
->size
- 8) / 8;
2378 bfd_put_32 (abfd
, count
, contents
+ 4);
2379 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
2380 (file_ptr
) sec
->output_offset
, sec
->size
);
2383 /* The .eh_frame_hdr format for DWARF frames:
2385 ubyte version (currently 1)
2386 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
2388 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2389 number (or DW_EH_PE_omit if there is no
2390 binary search table computed))
2391 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2392 or DW_EH_PE_omit if not present.
2393 DW_EH_PE_datarel is using address of
2394 .eh_frame_hdr section start as base)
2395 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2396 optionally followed by:
2397 [encoded] fde_count (total number of FDEs in .eh_frame section)
2398 fde_count x [encoded] initial_loc, fde
2399 (array of encoded pairs containing
2400 FDE initial_location field and FDE address,
2401 sorted by increasing initial_loc). */
2404 write_dwarf_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2406 struct elf_link_hash_table
*htab
;
2407 struct eh_frame_hdr_info
*hdr_info
;
2411 htab
= elf_hash_table (info
);
2412 hdr_info
= &htab
->eh_info
;
2413 sec
= hdr_info
->hdr_sec
;
2415 asection
*eh_frame_sec
;
2417 bfd_vma encoded_eh_frame
;
2419 size
= EH_FRAME_HDR_SIZE
;
2420 if (hdr_info
->u
.dwarf
.array
2421 && hdr_info
->array_count
== hdr_info
->u
.dwarf
.fde_count
)
2422 size
+= 4 + hdr_info
->u
.dwarf
.fde_count
* 8;
2423 contents
= (bfd_byte
*) bfd_malloc (size
);
2424 if (contents
== NULL
)
2427 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
2428 if (eh_frame_sec
== NULL
)
2434 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
2437 /* .eh_frame offset. */
2438 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
2439 (abfd
, info
, eh_frame_sec
, 0, sec
, 4, &encoded_eh_frame
);
2441 if (hdr_info
->u
.dwarf
.array
2442 && hdr_info
->array_count
== hdr_info
->u
.dwarf
.fde_count
)
2444 /* FDE count encoding. */
2445 contents
[2] = DW_EH_PE_udata4
;
2446 /* Search table encoding. */
2447 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
2451 contents
[2] = DW_EH_PE_omit
;
2452 contents
[3] = DW_EH_PE_omit
;
2454 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
2456 if (contents
[2] != DW_EH_PE_omit
)
2459 bool overlap
, overflow
;
2461 bfd_put_32 (abfd
, hdr_info
->u
.dwarf
.fde_count
,
2462 contents
+ EH_FRAME_HDR_SIZE
);
2463 qsort (hdr_info
->u
.dwarf
.array
, hdr_info
->u
.dwarf
.fde_count
,
2464 sizeof (*hdr_info
->u
.dwarf
.array
), vma_compare
);
2467 for (i
= 0; i
< hdr_info
->u
.dwarf
.fde_count
; i
++)
2471 val
= hdr_info
->u
.dwarf
.array
[i
].initial_loc
2472 - sec
->output_section
->vma
;
2473 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
2474 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
2475 && (hdr_info
->u
.dwarf
.array
[i
].initial_loc
2476 != sec
->output_section
->vma
+ val
))
2478 bfd_put_32 (abfd
, val
, contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
2479 val
= hdr_info
->u
.dwarf
.array
[i
].fde
- sec
->output_section
->vma
;
2480 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
2481 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
2482 && (hdr_info
->u
.dwarf
.array
[i
].fde
2483 != sec
->output_section
->vma
+ val
))
2485 bfd_put_32 (abfd
, val
, contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
2487 && (hdr_info
->u
.dwarf
.array
[i
].initial_loc
2488 < (hdr_info
->u
.dwarf
.array
[i
- 1].initial_loc
2489 + hdr_info
->u
.dwarf
.array
[i
- 1].range
)))
2493 _bfd_error_handler (_(".eh_frame_hdr entry overflow"));
2495 _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs"));
2496 if (overflow
|| overlap
)
2498 bfd_set_error (bfd_error_bad_value
);
2503 /* FIXME: octets_per_byte. */
2504 if (!bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
2505 (file_ptr
) sec
->output_offset
,
2510 free (hdr_info
->u
.dwarf
.array
);
2514 /* Write out .eh_frame_hdr section. This must be called after
2515 _bfd_elf_write_section_eh_frame has been called on all input
2516 .eh_frame sections. */
2519 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2521 struct elf_link_hash_table
*htab
;
2522 struct eh_frame_hdr_info
*hdr_info
;
2525 htab
= elf_hash_table (info
);
2526 hdr_info
= &htab
->eh_info
;
2527 sec
= hdr_info
->hdr_sec
;
2529 if (info
->eh_frame_hdr_type
== 0 || sec
== NULL
)
2532 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
2533 return write_compact_eh_frame_hdr (abfd
, info
);
2535 return write_dwarf_eh_frame_hdr (abfd
, info
);
2538 /* Return the width of FDE addresses. This is the default implementation. */
2541 _bfd_elf_eh_frame_address_size (bfd
*abfd
, const asection
*sec ATTRIBUTE_UNUSED
)
2543 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
2546 /* Decide whether we can use a PC-relative encoding within the given
2547 EH frame section. This is the default implementation. */
2550 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
2551 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2552 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
2557 /* Select an encoding for the given address. Preference is given to
2558 PC-relative addressing modes. */
2561 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
2562 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2563 asection
*osec
, bfd_vma offset
,
2564 asection
*loc_sec
, bfd_vma loc_offset
,
2567 *encoded
= osec
->vma
+ offset
-
2568 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
2569 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;