1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2015 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. ALIGNMENT is the
313 required alignment of ENTRY in bytes. */
316 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
320 if (entry
->size
== 4)
323 + extra_augmentation_string_bytes (entry
)
324 + extra_augmentation_data_bytes (entry
)
325 + alignment
- 1) & -alignment
;
328 /* Assume that the bytes between *ITER and END are CFA instructions.
329 Try to move *ITER past the first instruction and return true on
330 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
333 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
338 if (!read_byte (iter
, end
, &op
))
341 switch (op
& 0xc0 ? op
& 0xc0 : op
)
344 case DW_CFA_advance_loc
:
346 case DW_CFA_remember_state
:
347 case DW_CFA_restore_state
:
348 case DW_CFA_GNU_window_save
:
353 case DW_CFA_restore_extended
:
354 case DW_CFA_undefined
:
355 case DW_CFA_same_value
:
356 case DW_CFA_def_cfa_register
:
357 case DW_CFA_def_cfa_offset
:
358 case DW_CFA_def_cfa_offset_sf
:
359 case DW_CFA_GNU_args_size
:
360 /* One leb128 argument. */
361 return skip_leb128 (iter
, end
);
363 case DW_CFA_val_offset
:
364 case DW_CFA_val_offset_sf
:
365 case DW_CFA_offset_extended
:
366 case DW_CFA_register
:
368 case DW_CFA_offset_extended_sf
:
369 case DW_CFA_GNU_negative_offset_extended
:
370 case DW_CFA_def_cfa_sf
:
371 /* Two leb128 arguments. */
372 return (skip_leb128 (iter
, end
)
373 && skip_leb128 (iter
, end
));
375 case DW_CFA_def_cfa_expression
:
376 /* A variable-length argument. */
377 return (read_uleb128 (iter
, end
, &length
)
378 && skip_bytes (iter
, end
, length
));
380 case DW_CFA_expression
:
381 case DW_CFA_val_expression
:
382 /* A leb128 followed by a variable-length argument. */
383 return (skip_leb128 (iter
, end
)
384 && read_uleb128 (iter
, end
, &length
)
385 && skip_bytes (iter
, end
, length
));
388 return skip_bytes (iter
, end
, encoded_ptr_width
);
390 case DW_CFA_advance_loc1
:
391 return skip_bytes (iter
, end
, 1);
393 case DW_CFA_advance_loc2
:
394 return skip_bytes (iter
, end
, 2);
396 case DW_CFA_advance_loc4
:
397 return skip_bytes (iter
, end
, 4);
399 case DW_CFA_MIPS_advance_loc8
:
400 return skip_bytes (iter
, end
, 8);
407 /* Try to interpret the bytes between BUF and END as CFA instructions.
408 If every byte makes sense, return a pointer to the first DW_CFA_nop
409 padding byte, or END if there is no padding. Return null otherwise.
410 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
413 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
414 unsigned int *set_loc_count
)
420 if (*buf
== DW_CFA_nop
)
424 if (*buf
== DW_CFA_set_loc
)
426 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
433 /* Convert absolute encoding ENCODING into PC-relative form.
434 SIZE is the size of a pointer. */
437 make_pc_relative (unsigned char encoding
, unsigned int ptr_size
)
439 if ((encoding
& 0x7f) == DW_EH_PE_absptr
)
443 encoding
|= DW_EH_PE_sdata2
;
446 encoding
|= DW_EH_PE_sdata4
;
449 encoding
|= DW_EH_PE_sdata8
;
452 return encoding
| DW_EH_PE_pcrel
;
455 /* Examine each .eh_frame_entry section and discard those
456 those that are marked SEC_EXCLUDE. */
459 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info
*hdr_info
)
462 for (i
= 0; i
< hdr_info
->array_count
; i
++)
464 if (hdr_info
->u
.compact
.entries
[i
]->flags
& SEC_EXCLUDE
)
467 for (j
= i
+ 1; j
< hdr_info
->array_count
; j
++)
468 hdr_info
->u
.compact
.entries
[j
-1] = hdr_info
->u
.compact
.entries
[j
];
470 hdr_info
->array_count
--;
471 hdr_info
->u
.compact
.entries
[hdr_info
->array_count
] = NULL
;
477 /* Add a .eh_frame_entry section. */
480 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info
*hdr_info
,
483 if (hdr_info
->array_count
== hdr_info
->u
.compact
.allocated_entries
)
485 if (hdr_info
->u
.compact
.allocated_entries
== 0)
487 hdr_info
->frame_hdr_is_compact
= TRUE
;
488 hdr_info
->u
.compact
.allocated_entries
= 2;
489 hdr_info
->u
.compact
.entries
=
490 bfd_malloc (hdr_info
->u
.compact
.allocated_entries
491 * sizeof (hdr_info
->u
.compact
.entries
[0]));
495 hdr_info
->u
.compact
.allocated_entries
*= 2;
496 hdr_info
->u
.compact
.entries
=
497 bfd_realloc (hdr_info
->u
.compact
.entries
,
498 hdr_info
->u
.compact
.allocated_entries
499 * sizeof (hdr_info
->u
.compact
.entries
[0]));
502 BFD_ASSERT (hdr_info
->u
.compact
.entries
);
505 hdr_info
->u
.compact
.entries
[hdr_info
->array_count
++] = sec
;
508 /* Parse a .eh_frame_entry section. Figure out which text section it
512 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info
*info
,
513 asection
*sec
, struct elf_reloc_cookie
*cookie
)
515 struct elf_link_hash_table
*htab
;
516 struct eh_frame_hdr_info
*hdr_info
;
517 unsigned long r_symndx
;
520 htab
= elf_hash_table (info
);
521 hdr_info
= &htab
->eh_info
;
524 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
529 if (sec
->output_section
&& bfd_is_abs_section (sec
->output_section
))
531 /* At least one of the sections is being discarded from the
532 link, so we should just ignore them. */
536 if (cookie
->rel
== cookie
->relend
)
539 /* The first relocation is the function start. */
540 r_symndx
= cookie
->rel
->r_info
>> cookie
->r_sym_shift
;
541 if (r_symndx
== STN_UNDEF
)
544 text_sec
= _bfd_elf_section_for_symbol (cookie
, r_symndx
, FALSE
);
546 if (text_sec
== NULL
)
549 elf_section_eh_frame_entry (text_sec
) = sec
;
550 if (text_sec
->output_section
551 && bfd_is_abs_section (text_sec
->output_section
))
552 sec
->flags
|= SEC_EXCLUDE
;
554 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME_ENTRY
;
555 elf_section_data (sec
)->sec_info
= text_sec
;
556 bfd_elf_record_eh_frame_entry (hdr_info
, sec
);
560 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
561 information in the section's sec_info field on success. COOKIE
562 describes the relocations in SEC. */
565 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
566 asection
*sec
, struct elf_reloc_cookie
*cookie
)
568 #define REQUIRE(COND) \
571 goto free_no_table; \
574 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
576 struct eh_cie_fde
*this_inf
;
577 unsigned int hdr_length
, hdr_id
;
578 unsigned int cie_count
;
579 struct cie
*cie
, *local_cies
= NULL
;
580 struct elf_link_hash_table
*htab
;
581 struct eh_frame_hdr_info
*hdr_info
;
582 struct eh_frame_sec_info
*sec_info
= NULL
;
583 unsigned int ptr_size
;
584 unsigned int num_cies
;
585 unsigned int num_entries
;
586 elf_gc_mark_hook_fn gc_mark_hook
;
588 htab
= elf_hash_table (info
);
589 hdr_info
= &htab
->eh_info
;
592 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
594 /* This file does not contain .eh_frame information. */
598 if (bfd_is_abs_section (sec
->output_section
))
600 /* At least one of the sections is being discarded from the
601 link, so we should just ignore them. */
605 /* Read the frame unwind information from abfd. */
607 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
610 && bfd_get_32 (abfd
, ehbuf
) == 0
611 && cookie
->rel
== cookie
->relend
)
613 /* Empty .eh_frame section. */
618 /* If .eh_frame section size doesn't fit into int, we cannot handle
619 it (it would need to use 64-bit .eh_frame format anyway). */
620 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
622 ptr_size
= (get_elf_backend_data (abfd
)
623 ->elf_backend_eh_frame_address_size (abfd
, sec
));
624 REQUIRE (ptr_size
!= 0);
626 /* Go through the section contents and work out how many FDEs and
629 end
= ehbuf
+ sec
->size
;
636 /* Read the length of the entry. */
637 REQUIRE (skip_bytes (&buf
, end
, 4));
638 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
640 /* 64-bit .eh_frame is not supported. */
641 REQUIRE (hdr_length
!= 0xffffffff);
645 REQUIRE (skip_bytes (&buf
, end
, 4));
646 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
650 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
653 sec_info
= (struct eh_frame_sec_info
*)
654 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
655 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
658 /* We need to have a "struct cie" for each CIE in this section. */
659 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
660 REQUIRE (local_cies
);
662 /* FIXME: octets_per_byte. */
663 #define ENSURE_NO_RELOCS(buf) \
664 while (cookie->rel < cookie->relend \
665 && (cookie->rel->r_offset \
666 < (bfd_size_type) ((buf) - ehbuf))) \
668 REQUIRE (cookie->rel->r_info == 0); \
672 /* FIXME: octets_per_byte. */
673 #define SKIP_RELOCS(buf) \
674 while (cookie->rel < cookie->relend \
675 && (cookie->rel->r_offset \
676 < (bfd_size_type) ((buf) - ehbuf))) \
679 /* FIXME: octets_per_byte. */
680 #define GET_RELOC(buf) \
681 ((cookie->rel < cookie->relend \
682 && (cookie->rel->r_offset \
683 == (bfd_size_type) ((buf) - ehbuf))) \
684 ? cookie->rel : NULL)
688 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
689 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
692 bfd_byte
*start
, *insns
, *insns_end
;
693 bfd_size_type length
;
694 unsigned int set_loc_count
;
696 this_inf
= sec_info
->entry
+ sec_info
->count
;
699 /* Read the length of the entry. */
700 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
701 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
703 /* The CIE/FDE must be fully contained in this input section. */
704 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
705 end
= buf
+ hdr_length
;
707 this_inf
->offset
= last_fde
- ehbuf
;
708 this_inf
->size
= 4 + hdr_length
;
709 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
713 /* A zero-length CIE should only be found at the end of
715 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
716 ENSURE_NO_RELOCS (buf
);
721 REQUIRE (skip_bytes (&buf
, end
, 4));
722 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
726 unsigned int initial_insn_length
;
731 /* Point CIE to one of the section-local cie structures. */
732 cie
= local_cies
+ cie_count
++;
734 cie
->cie_inf
= this_inf
;
735 cie
->length
= hdr_length
;
737 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
739 /* Cannot handle unknown versions. */
740 REQUIRE (cie
->version
== 1
742 || cie
->version
== 4);
743 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
745 strcpy (cie
->augmentation
, (char *) buf
);
746 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
747 ENSURE_NO_RELOCS (buf
);
748 if (buf
[0] == 'e' && buf
[1] == 'h')
750 /* GCC < 3.0 .eh_frame CIE */
751 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
752 is private to each CIE, so we don't need it for anything.
754 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
757 if (cie
->version
>= 4)
759 REQUIRE (buf
+ 1 < end
);
760 REQUIRE (buf
[0] == ptr_size
);
761 REQUIRE (buf
[1] == 0);
764 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
765 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
766 if (cie
->version
== 1)
769 cie
->ra_column
= *buf
++;
772 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
773 ENSURE_NO_RELOCS (buf
);
774 cie
->lsda_encoding
= DW_EH_PE_omit
;
775 cie
->fde_encoding
= DW_EH_PE_omit
;
776 cie
->per_encoding
= DW_EH_PE_omit
;
777 aug
= cie
->augmentation
;
778 if (aug
[0] != 'e' || aug
[1] != 'h')
783 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
784 ENSURE_NO_RELOCS (buf
);
791 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
792 ENSURE_NO_RELOCS (buf
);
793 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
796 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
797 ENSURE_NO_RELOCS (buf
);
798 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
806 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
807 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
810 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
812 length
= -(buf
- ehbuf
) & (per_width
- 1);
813 REQUIRE (skip_bytes (&buf
, end
, length
));
815 this_inf
->u
.cie
.personality_offset
= buf
- start
;
816 ENSURE_NO_RELOCS (buf
);
817 /* Ensure we have a reloc here. */
818 REQUIRE (GET_RELOC (buf
));
819 cie
->personality
.reloc_index
820 = cookie
->rel
- cookie
->rels
;
821 /* Cope with MIPS-style composite relocations. */
824 while (GET_RELOC (buf
) != NULL
);
825 REQUIRE (skip_bytes (&buf
, end
, per_width
));
829 /* Unrecognized augmentation. Better bail out. */
834 /* For shared libraries, try to get rid of as many RELATIVE relocs
836 if (bfd_link_pic (info
)
837 && (get_elf_backend_data (abfd
)
838 ->elf_backend_can_make_relative_eh_frame
841 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
842 this_inf
->make_relative
= 1;
843 /* If the CIE doesn't already have an 'R' entry, it's fairly
844 easy to add one, provided that there's no aligned data
845 after the augmentation string. */
846 else if (cie
->fde_encoding
== DW_EH_PE_omit
847 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
849 if (*cie
->augmentation
== 0)
850 this_inf
->add_augmentation_size
= 1;
851 this_inf
->u
.cie
.add_fde_encoding
= 1;
852 this_inf
->make_relative
= 1;
855 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
856 cie
->can_make_lsda_relative
= 1;
859 /* If FDE encoding was not specified, it defaults to
861 if (cie
->fde_encoding
== DW_EH_PE_omit
)
862 cie
->fde_encoding
= DW_EH_PE_absptr
;
864 initial_insn_length
= end
- buf
;
865 cie
->initial_insn_length
= initial_insn_length
;
866 memcpy (cie
->initial_instructions
, buf
,
867 initial_insn_length
<= sizeof (cie
->initial_instructions
)
868 ? initial_insn_length
: sizeof (cie
->initial_instructions
));
870 buf
+= initial_insn_length
;
871 ENSURE_NO_RELOCS (buf
);
873 if (!bfd_link_relocatable (info
))
875 /* Keep info for merging cies. */
876 this_inf
->u
.cie
.u
.full_cie
= cie
;
877 this_inf
->u
.cie
.per_encoding_relative
878 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
883 /* Find the corresponding CIE. */
884 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
885 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
886 if (cie_offset
== cie
->cie_inf
->offset
)
889 /* Ensure this FDE references one of the CIEs in this input
891 REQUIRE (cie
!= local_cies
+ cie_count
);
892 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
893 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
894 this_inf
->add_augmentation_size
895 = cie
->cie_inf
->add_augmentation_size
;
897 ENSURE_NO_RELOCS (buf
);
898 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
902 REQUIRE (GET_RELOC (buf
));
904 /* Chain together the FDEs for each section. */
905 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
906 /* RSEC will be NULL if FDE was cleared out as it was belonging to
907 a discarded SHT_GROUP. */
910 REQUIRE (rsec
->owner
== abfd
);
911 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
912 elf_fde_list (rsec
) = this_inf
;
916 /* Skip the initial location and address range. */
918 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
919 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
921 SKIP_RELOCS (buf
- length
);
922 if (!GET_RELOC (buf
- length
)
923 && read_value (abfd
, buf
- length
, length
, FALSE
) == 0)
925 (*info
->callbacks
->minfo
)
926 (_("discarding zero address range FDE in %B(%A).\n"),
928 this_inf
->u
.fde
.cie_inf
= NULL
;
931 /* Skip the augmentation size, if present. */
932 if (cie
->augmentation
[0] == 'z')
933 REQUIRE (read_uleb128 (&buf
, end
, &length
));
937 /* Of the supported augmentation characters above, only 'L'
938 adds augmentation data to the FDE. This code would need to
939 be adjusted if any future augmentations do the same thing. */
940 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
943 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
944 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
945 this_inf
->lsda_offset
= buf
- start
;
946 /* If there's no 'z' augmentation, we don't know where the
947 CFA insns begin. Assume no padding. */
948 if (cie
->augmentation
[0] != 'z')
952 /* Skip over the augmentation data. */
953 REQUIRE (skip_bytes (&buf
, end
, length
));
956 buf
= last_fde
+ 4 + hdr_length
;
958 /* For NULL RSEC (cleared FDE belonging to a discarded section)
959 the relocations are commonly cleared. We do not sanity check if
960 all these relocations are cleared as (1) relocations to
961 .gcc_except_table will remain uncleared (they will get dropped
962 with the drop of this unused FDE) and (2) BFD already safely drops
963 relocations of any type to .eh_frame by
964 elf_section_ignore_discarded_relocs.
965 TODO: The .gcc_except_table entries should be also filtered as
966 .eh_frame entries; or GCC could rather use COMDAT for them. */
970 /* Try to interpret the CFA instructions and find the first
971 padding nop. Shrink this_inf's size so that it doesn't
972 include the padding. */
973 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
975 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
976 /* If we don't understand the CFA instructions, we can't know
977 what needs to be adjusted there. */
978 if (insns_end
== NULL
979 /* For the time being we don't support DW_CFA_set_loc in
981 || (set_loc_count
&& this_inf
->cie
))
983 this_inf
->size
-= end
- insns_end
;
984 if (insns_end
!= end
&& this_inf
->cie
)
986 cie
->initial_insn_length
-= end
- insns_end
;
987 cie
->length
-= end
- insns_end
;
990 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
991 || this_inf
->make_relative
))
996 this_inf
->set_loc
= (unsigned int *)
997 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
998 REQUIRE (this_inf
->set_loc
);
999 this_inf
->set_loc
[0] = set_loc_count
;
1004 if (*p
== DW_CFA_set_loc
)
1005 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
1006 REQUIRE (skip_cfa_op (&p
, end
, length
));
1010 this_inf
->removed
= 1;
1011 this_inf
->fde_encoding
= cie
->fde_encoding
;
1012 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
1015 BFD_ASSERT (sec_info
->count
== num_entries
);
1016 BFD_ASSERT (cie_count
== num_cies
);
1018 elf_section_data (sec
)->sec_info
= sec_info
;
1019 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
1020 if (!bfd_link_relocatable (info
))
1022 /* Keep info for merging cies. */
1023 sec_info
->cies
= local_cies
;
1029 (*info
->callbacks
->einfo
)
1030 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1032 hdr_info
->u
.dwarf
.table
= FALSE
;
1043 /* Order eh_frame_hdr entries by the VMA of their text section. */
1046 cmp_eh_frame_hdr (const void *a
, const void *b
)
1052 sec
= *(asection
*const *)a
;
1053 sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1054 text_a
= sec
->output_section
->vma
+ sec
->output_offset
;
1055 sec
= *(asection
*const *)b
;
1056 sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1057 text_b
= sec
->output_section
->vma
+ sec
->output_offset
;
1059 if (text_a
< text_b
)
1061 return text_a
> text_b
;
1065 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1066 referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1069 add_eh_frame_hdr_terminator (asection
*sec
,
1078 /* See if there is a gap (presumably a text section without unwind info)
1079 between these two entries. */
1080 text_sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1081 end
= text_sec
->output_section
->vma
+ text_sec
->output_offset
1083 text_sec
= (asection
*) elf_section_data (next
)->sec_info
;
1084 next_start
= text_sec
->output_section
->vma
+ text_sec
->output_offset
;
1085 if (end
== next_start
)
1089 /* Add space for a CANTUNWIND terminator. */
1091 sec
->rawsize
= sec
->size
;
1093 bfd_set_section_size (sec
->owner
, sec
, sec
->size
+ 8);
1096 /* Finish a pass over all .eh_frame_entry sections. */
1099 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
1101 struct eh_frame_hdr_info
*hdr_info
;
1104 hdr_info
= &elf_hash_table (info
)->eh_info
;
1106 if (info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
1107 || hdr_info
->array_count
== 0)
1110 bfd_elf_discard_eh_frame_entry (hdr_info
);
1112 qsort (hdr_info
->u
.compact
.entries
, hdr_info
->array_count
,
1113 sizeof (asection
*), cmp_eh_frame_hdr
);
1115 for (i
= 0; i
< hdr_info
->array_count
- 1; i
++)
1117 add_eh_frame_hdr_terminator (hdr_info
->u
.compact
.entries
[i
],
1118 hdr_info
->u
.compact
.entries
[i
+ 1]);
1121 /* Add a CANTUNWIND terminator after the last entry. */
1122 add_eh_frame_hdr_terminator (hdr_info
->u
.compact
.entries
[i
], NULL
);
1126 /* Mark all relocations against CIE or FDE ENT, which occurs in
1127 .eh_frame section SEC. COOKIE describes the relocations in SEC;
1128 its "rel" field can be changed freely. */
1131 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
1132 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
1133 struct elf_reloc_cookie
*cookie
)
1135 /* FIXME: octets_per_byte. */
1136 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1137 cookie
->rel
< cookie
->relend
1138 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
1140 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
1146 /* Mark all the relocations against FDEs that relate to code in input
1147 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1148 relocations are described by COOKIE. */
1151 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
1152 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
1153 struct elf_reloc_cookie
*cookie
)
1155 struct eh_cie_fde
*fde
, *cie
;
1157 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
1159 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
1162 /* At this stage, all cie_inf fields point to local CIEs, so we
1163 can use the same cookie to refer to them. */
1164 cie
= fde
->u
.fde
.cie_inf
;
1165 if (cie
!= NULL
&& !cie
->u
.cie
.gc_mark
)
1167 cie
->u
.cie
.gc_mark
= 1;
1168 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
1175 /* Input section SEC of ABFD is an .eh_frame section that contains the
1176 CIE described by CIE_INF. Return a version of CIE_INF that is going
1177 to be kept in the output, adding CIE_INF to the output if necessary.
1179 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1180 relocations in REL. */
1182 static struct eh_cie_fde
*
1183 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1184 struct eh_frame_hdr_info
*hdr_info
,
1185 struct elf_reloc_cookie
*cookie
,
1186 struct eh_cie_fde
*cie_inf
)
1188 unsigned long r_symndx
;
1189 struct cie
*cie
, *new_cie
;
1190 Elf_Internal_Rela
*rel
;
1193 /* Use CIE_INF if we have already decided to keep it. */
1194 if (!cie_inf
->removed
)
1197 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1198 if (cie_inf
->u
.cie
.merged
)
1199 return cie_inf
->u
.cie
.u
.merged_with
;
1201 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1203 /* Assume we will need to keep CIE_INF. */
1204 cie_inf
->removed
= 0;
1205 cie_inf
->u
.cie
.u
.sec
= sec
;
1207 /* If we are not merging CIEs, use CIE_INF. */
1211 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1213 bfd_boolean per_binds_local
;
1215 /* Work out the address of personality routine, or at least
1216 enough info that we could calculate the address had we made a
1217 final section layout. The symbol on the reloc is enough,
1218 either the hash for a global, or (bfd id, index) pair for a
1219 local. The assumption here is that no one uses addends on
1221 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1222 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1224 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1225 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1228 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1229 if (r_symndx
>= cookie
->locsymcount
1230 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1232 struct elf_link_hash_entry
*h
;
1234 r_symndx
-= cookie
->extsymoff
;
1235 h
= cookie
->sym_hashes
[r_symndx
];
1237 while (h
->root
.type
== bfd_link_hash_indirect
1238 || h
->root
.type
== bfd_link_hash_warning
)
1239 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1241 cie
->personality
.h
= h
;
1242 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1246 Elf_Internal_Sym
*sym
;
1249 sym
= &cookie
->locsyms
[r_symndx
];
1250 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1251 if (sym_sec
== NULL
)
1254 if (sym_sec
->kept_section
!= NULL
)
1255 sym_sec
= sym_sec
->kept_section
;
1256 if (sym_sec
->output_section
== NULL
)
1259 cie
->local_personality
= 1;
1260 cie
->personality
.sym
.bfd_id
= abfd
->id
;
1261 cie
->personality
.sym
.index
= r_symndx
;
1262 per_binds_local
= TRUE
;
1266 && bfd_link_pic (info
)
1267 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1268 && (get_elf_backend_data (abfd
)
1269 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1271 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1272 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1276 /* See if we can merge this CIE with an earlier one. */
1277 cie_compute_hash (cie
);
1278 if (hdr_info
->u
.dwarf
.cies
== NULL
)
1280 hdr_info
->u
.dwarf
.cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1281 if (hdr_info
->u
.dwarf
.cies
== NULL
)
1284 loc
= htab_find_slot_with_hash (hdr_info
->u
.dwarf
.cies
, cie
,
1289 new_cie
= (struct cie
*) *loc
;
1290 if (new_cie
== NULL
)
1292 /* Keep CIE_INF and record it in the hash table. */
1293 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1294 if (new_cie
== NULL
)
1297 memcpy (new_cie
, cie
, sizeof (struct cie
));
1302 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1303 cie_inf
->removed
= 1;
1304 cie_inf
->u
.cie
.merged
= 1;
1305 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1306 if (cie_inf
->u
.cie
.make_lsda_relative
)
1307 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1309 return new_cie
->cie_inf
;
1312 /* This function is called for each input file before the .eh_frame
1313 section is relocated. It discards duplicate CIEs and FDEs for discarded
1314 functions. The function returns TRUE iff any entries have been
1318 _bfd_elf_discard_section_eh_frame
1319 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1320 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1321 struct elf_reloc_cookie
*cookie
)
1323 struct eh_cie_fde
*ent
;
1324 struct eh_frame_sec_info
*sec_info
;
1325 struct eh_frame_hdr_info
*hdr_info
;
1326 unsigned int ptr_size
, offset
;
1328 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1331 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1332 if (sec_info
== NULL
)
1335 ptr_size
= (get_elf_backend_data (sec
->owner
)
1336 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1338 hdr_info
= &elf_hash_table (info
)->eh_info
;
1339 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1341 /* There should only be one zero terminator, on the last input
1342 file supplying .eh_frame (crtend.o). Remove any others. */
1343 ent
->removed
= sec
->map_head
.s
!= NULL
;
1344 else if (!ent
->cie
&& ent
->u
.fde
.cie_inf
!= NULL
)
1347 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1350 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1352 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1353 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1358 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1359 /* FIXME: octets_per_byte. */
1360 BFD_ASSERT (cookie
->rel
< cookie
->relend
1361 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1362 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1366 if (bfd_link_pic (info
)
1367 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1368 && ent
->make_relative
== 0)
1369 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1371 /* If a shared library uses absolute pointers
1372 which we cannot turn into PC relative,
1373 don't create the binary search table,
1374 since it is affected by runtime relocations. */
1375 hdr_info
->u
.dwarf
.table
= FALSE
;
1376 (*info
->callbacks
->einfo
)
1377 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1378 " table being created.\n"), abfd
, sec
);
1381 hdr_info
->u
.dwarf
.fde_count
++;
1382 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1383 cookie
, ent
->u
.fde
.cie_inf
);
1389 free (sec_info
->cies
);
1390 sec_info
->cies
= NULL
;
1394 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1397 ent
->new_offset
= offset
;
1398 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1401 sec
->rawsize
= sec
->size
;
1403 return offset
!= sec
->rawsize
;
1406 /* This function is called for .eh_frame_hdr section after
1407 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1408 input sections. It finalizes the size of .eh_frame_hdr section. */
1411 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1413 struct elf_link_hash_table
*htab
;
1414 struct eh_frame_hdr_info
*hdr_info
;
1417 htab
= elf_hash_table (info
);
1418 hdr_info
= &htab
->eh_info
;
1420 if (!hdr_info
->frame_hdr_is_compact
&& hdr_info
->u
.dwarf
.cies
!= NULL
)
1422 htab_delete (hdr_info
->u
.dwarf
.cies
);
1423 hdr_info
->u
.dwarf
.cies
= NULL
;
1426 sec
= hdr_info
->hdr_sec
;
1430 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
1432 /* For compact frames we only add the header. The actual table comes
1433 from the .eh_frame_entry sections. */
1438 sec
->size
= EH_FRAME_HDR_SIZE
;
1439 if (hdr_info
->u
.dwarf
.table
)
1440 sec
->size
+= 4 + hdr_info
->u
.dwarf
.fde_count
* 8;
1443 elf_eh_frame_hdr (abfd
) = sec
;
1447 /* Return true if there is at least one non-empty .eh_frame section in
1448 input files. Can only be called after ld has mapped input to
1449 output sections, and before sections are stripped. */
1452 _bfd_elf_eh_frame_present (struct bfd_link_info
*info
)
1454 asection
*eh
= bfd_get_section_by_name (info
->output_bfd
, ".eh_frame");
1459 /* Count only sections which have at least a single CIE or FDE.
1460 There cannot be any CIE or FDE <= 8 bytes. */
1461 for (eh
= eh
->map_head
.s
; eh
!= NULL
; eh
= eh
->map_head
.s
)
1468 /* Return true if there is at least one .eh_frame_entry section in
1472 _bfd_elf_eh_frame_entry_present (struct bfd_link_info
*info
)
1477 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link
.next
)
1479 for (o
= abfd
->sections
; o
; o
= o
->next
)
1481 const char *name
= bfd_get_section_name (abfd
, o
);
1483 if (strcmp (name
, ".eh_frame_entry")
1484 && !bfd_is_abs_section (o
->output_section
))
1491 /* This function is called from size_dynamic_sections.
1492 It needs to decide whether .eh_frame_hdr should be output or not,
1493 because when the dynamic symbol table has been sized it is too late
1494 to strip sections. */
1497 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1499 struct elf_link_hash_table
*htab
;
1500 struct eh_frame_hdr_info
*hdr_info
;
1501 struct bfd_link_hash_entry
*bh
= NULL
;
1502 struct elf_link_hash_entry
*h
;
1504 htab
= elf_hash_table (info
);
1505 hdr_info
= &htab
->eh_info
;
1506 if (hdr_info
->hdr_sec
== NULL
)
1509 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
)
1510 || info
->eh_frame_hdr_type
== 0
1511 || (info
->eh_frame_hdr_type
== DWARF2_EH_HDR
1512 && !_bfd_elf_eh_frame_present (info
))
1513 || (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
1514 && !_bfd_elf_eh_frame_entry_present (info
)))
1516 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1517 hdr_info
->hdr_sec
= NULL
;
1521 /* Add a hidden symbol so that systems without access to PHDRs can
1523 if (! (_bfd_generic_link_add_one_symbol
1524 (info
, info
->output_bfd
, "__GNU_EH_FRAME_HDR", BSF_LOCAL
,
1525 hdr_info
->hdr_sec
, 0, NULL
, FALSE
, FALSE
, &bh
)))
1528 h
= (struct elf_link_hash_entry
*) bh
;
1530 h
->other
= STV_HIDDEN
;
1531 get_elf_backend_data
1532 (info
->output_bfd
)->elf_backend_hide_symbol (info
, h
, TRUE
);
1534 if (!hdr_info
->frame_hdr_is_compact
)
1535 hdr_info
->u
.dwarf
.table
= TRUE
;
1539 /* Adjust an address in the .eh_frame section. Given OFFSET within
1540 SEC, this returns the new offset in the adjusted .eh_frame section,
1541 or -1 if the address refers to a CIE/FDE which has been removed
1542 or to offset with dynamic relocation which is no longer needed. */
1545 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1546 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1550 struct eh_frame_sec_info
*sec_info
;
1551 unsigned int lo
, hi
, mid
;
1553 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1555 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1557 if (offset
>= sec
->rawsize
)
1558 return offset
- sec
->rawsize
+ sec
->size
;
1561 hi
= sec_info
->count
;
1565 mid
= (lo
+ hi
) / 2;
1566 if (offset
< sec_info
->entry
[mid
].offset
)
1569 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1575 BFD_ASSERT (lo
< hi
);
1577 /* FDE or CIE was removed. */
1578 if (sec_info
->entry
[mid
].removed
)
1579 return (bfd_vma
) -1;
1581 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1582 no need for run-time relocation against the personality field. */
1583 if (sec_info
->entry
[mid
].cie
1584 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1585 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1586 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1587 return (bfd_vma
) -2;
1589 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1590 relocation against FDE's initial_location field. */
1591 if (!sec_info
->entry
[mid
].cie
1592 && sec_info
->entry
[mid
].make_relative
1593 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1594 return (bfd_vma
) -2;
1596 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1597 for run-time relocation against LSDA field. */
1598 if (!sec_info
->entry
[mid
].cie
1599 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1600 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1601 + sec_info
->entry
[mid
].lsda_offset
))
1602 return (bfd_vma
) -2;
1604 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1605 relocation against DW_CFA_set_loc's arguments. */
1606 if (sec_info
->entry
[mid
].set_loc
1607 && sec_info
->entry
[mid
].make_relative
1608 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1609 + sec_info
->entry
[mid
].set_loc
[1]))
1613 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1614 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1615 + sec_info
->entry
[mid
].set_loc
[cnt
])
1616 return (bfd_vma
) -2;
1619 /* Any new augmentation bytes go before the first relocation. */
1620 return (offset
+ sec_info
->entry
[mid
].new_offset
1621 - sec_info
->entry
[mid
].offset
1622 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1623 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1626 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1627 Also check that the contents look sane. */
1630 _bfd_elf_write_section_eh_frame_entry (bfd
*abfd
, struct bfd_link_info
*info
,
1631 asection
*sec
, bfd_byte
*contents
)
1633 const struct elf_backend_data
*bed
;
1634 bfd_byte cantunwind
[8];
1638 asection
*text_sec
= (asection
*) elf_section_data (sec
)->sec_info
;
1641 sec
->rawsize
= sec
->size
;
1643 BFD_ASSERT (sec
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME_ENTRY
);
1645 /* Check to make sure that the text section corresponding to this eh_frame_entry
1646 section has not been excluded. In particular, mips16 stub entries will be
1647 excluded outside of the normal process. */
1648 if (sec
->flags
& SEC_EXCLUDE
1649 || text_sec
->flags
& SEC_EXCLUDE
)
1652 if (!bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1653 sec
->output_offset
, sec
->rawsize
))
1656 last_addr
= bfd_get_signed_32 (abfd
, contents
);
1657 /* Check that all the entries are in order. */
1658 for (offset
= 8; offset
< sec
->rawsize
; offset
+= 8)
1660 addr
= bfd_get_signed_32 (abfd
, contents
+ offset
) + offset
;
1661 if (addr
<= last_addr
)
1663 (*_bfd_error_handler
) (_("%B: %s not in order"), sec
->owner
, sec
->name
);
1670 addr
= text_sec
->output_section
->vma
+ text_sec
->output_offset
1673 addr
-= (sec
->output_section
->vma
+ sec
->output_offset
+ sec
->rawsize
);
1676 (*_bfd_error_handler
) (_("%B: %s invalid input section size"),
1677 sec
->owner
, sec
->name
);
1678 bfd_set_error (bfd_error_bad_value
);
1681 if (last_addr
>= addr
+ sec
->rawsize
)
1683 (*_bfd_error_handler
) (_("%B: %s points past end of text section"),
1684 sec
->owner
, sec
->name
);
1685 bfd_set_error (bfd_error_bad_value
);
1689 if (sec
->size
== sec
->rawsize
)
1692 bed
= get_elf_backend_data (abfd
);
1693 BFD_ASSERT (sec
->size
== sec
->rawsize
+ 8);
1694 BFD_ASSERT ((addr
& 1) == 0);
1695 BFD_ASSERT (bed
->cant_unwind_opcode
);
1697 bfd_put_32 (abfd
, addr
, cantunwind
);
1698 bfd_put_32 (abfd
, (*bed
->cant_unwind_opcode
) (info
), cantunwind
+ 4);
1699 return bfd_set_section_contents (abfd
, sec
->output_section
, cantunwind
,
1700 sec
->output_offset
+ sec
->rawsize
, 8);
1703 /* Write out .eh_frame section. This is called with the relocated
1707 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1708 struct bfd_link_info
*info
,
1712 struct eh_frame_sec_info
*sec_info
;
1713 struct elf_link_hash_table
*htab
;
1714 struct eh_frame_hdr_info
*hdr_info
;
1715 unsigned int ptr_size
;
1716 struct eh_cie_fde
*ent
;
1717 bfd_size_type sec_size
;
1719 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1720 /* FIXME: octets_per_byte. */
1721 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1722 sec
->output_offset
, sec
->size
);
1724 ptr_size
= (get_elf_backend_data (abfd
)
1725 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1726 BFD_ASSERT (ptr_size
!= 0);
1728 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1729 htab
= elf_hash_table (info
);
1730 hdr_info
= &htab
->eh_info
;
1732 if (hdr_info
->u
.dwarf
.table
&& hdr_info
->u
.dwarf
.array
== NULL
)
1734 hdr_info
->frame_hdr_is_compact
= FALSE
;
1735 hdr_info
->u
.dwarf
.array
= (struct eh_frame_array_ent
*)
1736 bfd_malloc (hdr_info
->u
.dwarf
.fde_count
1737 * sizeof (*hdr_info
->u
.dwarf
.array
));
1739 if (hdr_info
->u
.dwarf
.array
== NULL
)
1742 /* The new offsets can be bigger or smaller than the original offsets.
1743 We therefore need to make two passes over the section: one backward
1744 pass to move entries up and one forward pass to move entries down.
1745 The two passes won't interfere with each other because entries are
1747 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1748 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1749 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1751 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1752 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1753 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1755 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1757 unsigned char *buf
, *end
;
1758 unsigned int new_size
;
1765 /* Any terminating FDE must be at the end of the section. */
1766 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1770 buf
= contents
+ ent
->new_offset
;
1771 end
= buf
+ ent
->size
;
1772 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1774 /* Update the size. It may be shrinked. */
1775 bfd_put_32 (abfd
, new_size
- 4, buf
);
1777 /* Filling the extra bytes with DW_CFA_nops. */
1778 if (new_size
!= ent
->size
)
1779 memset (end
, 0, new_size
- ent
->size
);
1784 if (ent
->make_relative
1785 || ent
->u
.cie
.make_lsda_relative
1786 || ent
->u
.cie
.per_encoding_relative
)
1789 unsigned int action
, extra_string
, extra_data
;
1790 unsigned int per_width
, per_encoding
;
1792 /* Need to find 'R' or 'L' augmentation's argument and modify
1793 DW_EH_PE_* value. */
1794 action
= ((ent
->make_relative
? 1 : 0)
1795 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1796 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1797 extra_string
= extra_augmentation_string_bytes (ent
);
1798 extra_data
= extra_augmentation_data_bytes (ent
);
1800 /* Skip length, id and version. */
1803 buf
+= strlen (aug
) + 1;
1804 skip_leb128 (&buf
, end
);
1805 skip_leb128 (&buf
, end
);
1806 skip_leb128 (&buf
, end
);
1809 /* The uleb128 will always be a single byte for the kind
1810 of augmentation strings that we're prepared to handle. */
1811 *buf
++ += extra_data
;
1815 /* Make room for the new augmentation string and data bytes. */
1816 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1817 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1818 buf
+= extra_string
;
1819 end
+= extra_string
+ extra_data
;
1821 if (ent
->add_augmentation_size
)
1824 *buf
++ = extra_data
- 1;
1826 if (ent
->u
.cie
.add_fde_encoding
)
1828 BFD_ASSERT (action
& 1);
1830 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
1840 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1841 *buf
= make_pc_relative (*buf
, ptr_size
);
1847 if (ent
->u
.cie
.make_per_encoding_relative
)
1848 *buf
= make_pc_relative (*buf
, ptr_size
);
1849 per_encoding
= *buf
++;
1850 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1851 BFD_ASSERT (per_width
!= 0);
1852 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1853 == ent
->u
.cie
.per_encoding_relative
);
1854 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
1856 + ((buf
- contents
+ per_width
- 1)
1857 & ~((bfd_size_type
) per_width
- 1)));
1862 val
= read_value (abfd
, buf
, per_width
,
1863 get_DW_EH_PE_signed (per_encoding
));
1864 if (ent
->u
.cie
.make_per_encoding_relative
)
1865 val
-= (sec
->output_section
->vma
1866 + sec
->output_offset
1867 + (buf
- contents
));
1870 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1871 val
-= extra_string
+ extra_data
;
1873 write_value (abfd
, buf
, val
, per_width
);
1881 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1882 *buf
= make_pc_relative (*buf
, ptr_size
);
1897 bfd_vma value
, address
;
1900 struct eh_cie_fde
*cie
;
1903 cie
= ent
->u
.fde
.cie_inf
;
1905 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1906 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1907 bfd_put_32 (abfd
, value
, buf
);
1908 if (bfd_link_relocatable (info
))
1911 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1912 value
= read_value (abfd
, buf
, width
,
1913 get_DW_EH_PE_signed (ent
->fde_encoding
));
1917 switch (ent
->fde_encoding
& 0x70)
1919 case DW_EH_PE_textrel
:
1920 BFD_ASSERT (hdr_info
== NULL
);
1922 case DW_EH_PE_datarel
:
1924 switch (abfd
->arch_info
->arch
)
1927 BFD_ASSERT (elf_gp (abfd
) != 0);
1928 address
+= elf_gp (abfd
);
1931 (*info
->callbacks
->einfo
)
1932 (_("%P: DW_EH_PE_datarel unspecified"
1933 " for this architecture.\n"));
1937 BFD_ASSERT (htab
->hgot
!= NULL
1938 && ((htab
->hgot
->root
.type
1939 == bfd_link_hash_defined
)
1940 || (htab
->hgot
->root
.type
1941 == bfd_link_hash_defweak
)));
1943 += (htab
->hgot
->root
.u
.def
.value
1944 + htab
->hgot
->root
.u
.def
.section
->output_offset
1945 + (htab
->hgot
->root
.u
.def
.section
->output_section
1951 case DW_EH_PE_pcrel
:
1952 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1953 address
+= (sec
->output_section
->vma
1954 + sec
->output_offset
1958 if (ent
->make_relative
)
1959 value
-= (sec
->output_section
->vma
1960 + sec
->output_offset
1961 + ent
->new_offset
+ 8);
1962 write_value (abfd
, buf
, value
, width
);
1969 /* The address calculation may overflow, giving us a
1970 value greater than 4G on a 32-bit target when
1971 dwarf_vma is 64-bit. */
1972 if (sizeof (address
) > 4 && ptr_size
== 4)
1973 address
&= 0xffffffff;
1974 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
].initial_loc
1976 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
].range
1977 = read_value (abfd
, buf
+ width
, width
, FALSE
);
1978 hdr_info
->u
.dwarf
.array
[hdr_info
->array_count
++].fde
1979 = (sec
->output_section
->vma
1980 + sec
->output_offset
1984 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
1985 || cie
->u
.cie
.make_lsda_relative
)
1987 buf
+= ent
->lsda_offset
;
1988 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1989 value
= read_value (abfd
, buf
, width
,
1990 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1993 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1994 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1995 else if (cie
->u
.cie
.make_lsda_relative
)
1996 value
-= (sec
->output_section
->vma
1997 + sec
->output_offset
1998 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1999 write_value (abfd
, buf
, value
, width
);
2002 else if (ent
->add_augmentation_size
)
2004 /* Skip the PC and length and insert a zero byte for the
2005 augmentation size. */
2007 memmove (buf
+ 1, buf
, end
- buf
);
2013 /* Adjust DW_CFA_set_loc. */
2017 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
2018 new_offset
= ent
->new_offset
+ 8
2019 + extra_augmentation_string_bytes (ent
)
2020 + extra_augmentation_data_bytes (ent
);
2022 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
2024 buf
= start
+ ent
->set_loc
[cnt
];
2026 value
= read_value (abfd
, buf
, width
,
2027 get_DW_EH_PE_signed (ent
->fde_encoding
));
2031 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
2032 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
2033 if (ent
->make_relative
)
2034 value
-= (sec
->output_section
->vma
2035 + sec
->output_offset
2036 + new_offset
+ ent
->set_loc
[cnt
]);
2037 write_value (abfd
, buf
, value
, width
);
2043 /* We don't align the section to its section alignment since the
2044 runtime library only expects all CIE/FDE records aligned at
2045 the pointer size. _bfd_elf_discard_section_eh_frame should
2046 have padded CIE/FDE records to multiple of pointer size with
2047 size_of_output_cie_fde. */
2048 sec_size
= sec
->size
;
2049 if (sec_info
->count
!= 0
2050 && sec_info
->entry
[sec_info
->count
- 1].size
== 4)
2052 if ((sec_size
% ptr_size
) != 0)
2055 /* FIXME: octets_per_byte. */
2056 return bfd_set_section_contents (abfd
, sec
->output_section
,
2057 contents
, (file_ptr
) sec
->output_offset
,
2061 /* Helper function used to sort .eh_frame_hdr search table by increasing
2062 VMA of FDE initial location. */
2065 vma_compare (const void *a
, const void *b
)
2067 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
2068 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
2069 if (p
->initial_loc
> q
->initial_loc
)
2071 if (p
->initial_loc
< q
->initial_loc
)
2073 if (p
->range
> q
->range
)
2075 if (p
->range
< q
->range
)
2080 /* Reorder .eh_frame_entry sections to match the associated text sections.
2081 This routine is called during the final linking step, just before writing
2082 the contents. At this stage, sections in the eh_frame_hdr_info are already
2083 sorted in order of increasing text section address and so we simply need
2084 to make the .eh_frame_entrys follow that same order. Note that it is
2085 invalid for a linker script to try to force a particular order of
2086 .eh_frame_entry sections. */
2089 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info
*info
)
2091 asection
*sec
= NULL
;
2093 struct eh_frame_hdr_info
*hdr_info
;
2096 struct bfd_link_order
*p
;
2098 hdr_info
= &elf_hash_table (info
)->eh_info
;
2100 if (hdr_info
->hdr_sec
== NULL
2101 || info
->eh_frame_hdr_type
!= COMPACT_EH_HDR
2102 || hdr_info
->array_count
== 0)
2105 /* Change section output offsets to be in text section order. */
2107 osec
= hdr_info
->u
.compact
.entries
[0]->output_section
;
2108 for (i
= 0; i
< hdr_info
->array_count
; i
++)
2110 sec
= hdr_info
->u
.compact
.entries
[i
];
2111 if (sec
->output_section
!= osec
)
2113 (*_bfd_error_handler
)
2114 (_("Invalid output section for .eh_frame_entry: %s"),
2115 sec
->output_section
->name
);
2118 sec
->output_offset
= offset
;
2119 offset
+= sec
->size
;
2123 /* Fix the link_order to match. */
2124 for (p
= sec
->output_section
->map_head
.link_order
; p
!= NULL
; p
= p
->next
)
2126 if (p
->type
!= bfd_indirect_link_order
)
2129 p
->offset
= p
->u
.indirect
.section
->output_offset
;
2130 if (p
->next
!= NULL
)
2136 (*_bfd_error_handler
)
2137 (_("Invalid contents in %s section"), osec
->name
);
2144 /* The .eh_frame_hdr format for Compact EH frames:
2146 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2147 uint32_t count (Number of entries in table)
2148 [array from .eh_frame_entry sections] */
2151 write_compact_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2153 struct elf_link_hash_table
*htab
;
2154 struct eh_frame_hdr_info
*hdr_info
;
2156 const struct elf_backend_data
*bed
;
2158 bfd_byte contents
[8];
2161 htab
= elf_hash_table (info
);
2162 hdr_info
= &htab
->eh_info
;
2163 sec
= hdr_info
->hdr_sec
;
2168 for (i
= 0; i
< sizeof (contents
); i
++)
2171 contents
[0] = COMPACT_EH_HDR
;
2172 bed
= get_elf_backend_data (abfd
);
2174 BFD_ASSERT (bed
->compact_eh_encoding
);
2175 contents
[1] = (*bed
->compact_eh_encoding
) (info
);
2177 count
= (sec
->output_section
->size
- 8) / 8;
2178 bfd_put_32 (abfd
, count
, contents
+ 4);
2179 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
2180 (file_ptr
) sec
->output_offset
, sec
->size
);
2183 /* The .eh_frame_hdr format for DWARF frames:
2185 ubyte version (currently 1)
2186 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
2188 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2189 number (or DW_EH_PE_omit if there is no
2190 binary search table computed))
2191 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2192 or DW_EH_PE_omit if not present.
2193 DW_EH_PE_datarel is using address of
2194 .eh_frame_hdr section start as base)
2195 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2196 optionally followed by:
2197 [encoded] fde_count (total number of FDEs in .eh_frame section)
2198 fde_count x [encoded] initial_loc, fde
2199 (array of encoded pairs containing
2200 FDE initial_location field and FDE address,
2201 sorted by increasing initial_loc). */
2204 write_dwarf_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2206 struct elf_link_hash_table
*htab
;
2207 struct eh_frame_hdr_info
*hdr_info
;
2209 bfd_boolean retval
= TRUE
;
2211 htab
= elf_hash_table (info
);
2212 hdr_info
= &htab
->eh_info
;
2213 sec
= hdr_info
->hdr_sec
;
2215 asection
*eh_frame_sec
;
2217 bfd_vma encoded_eh_frame
;
2219 size
= EH_FRAME_HDR_SIZE
;
2220 if (hdr_info
->u
.dwarf
.array
2221 && hdr_info
->array_count
== hdr_info
->u
.dwarf
.fde_count
)
2222 size
+= 4 + hdr_info
->u
.dwarf
.fde_count
* 8;
2223 contents
= (bfd_byte
*) bfd_malloc (size
);
2224 if (contents
== NULL
)
2227 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
2228 if (eh_frame_sec
== NULL
)
2234 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
2237 /* .eh_frame offset. */
2238 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
2239 (abfd
, info
, eh_frame_sec
, 0, sec
, 4, &encoded_eh_frame
);
2241 if (hdr_info
->u
.dwarf
.array
2242 && hdr_info
->array_count
== hdr_info
->u
.dwarf
.fde_count
)
2244 /* FDE count encoding. */
2245 contents
[2] = DW_EH_PE_udata4
;
2246 /* Search table encoding. */
2247 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
2251 contents
[2] = DW_EH_PE_omit
;
2252 contents
[3] = DW_EH_PE_omit
;
2254 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
2256 if (contents
[2] != DW_EH_PE_omit
)
2259 bfd_boolean overlap
, overflow
;
2261 bfd_put_32 (abfd
, hdr_info
->u
.dwarf
.fde_count
,
2262 contents
+ EH_FRAME_HDR_SIZE
);
2263 qsort (hdr_info
->u
.dwarf
.array
, hdr_info
->u
.dwarf
.fde_count
,
2264 sizeof (*hdr_info
->u
.dwarf
.array
), vma_compare
);
2267 for (i
= 0; i
< hdr_info
->u
.dwarf
.fde_count
; i
++)
2271 val
= hdr_info
->u
.dwarf
.array
[i
].initial_loc
2272 - sec
->output_section
->vma
;
2273 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
2274 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
2275 && (hdr_info
->u
.dwarf
.array
[i
].initial_loc
2276 != sec
->output_section
->vma
+ val
))
2278 bfd_put_32 (abfd
, val
, contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
2279 val
= hdr_info
->u
.dwarf
.array
[i
].fde
- sec
->output_section
->vma
;
2280 val
= ((val
& 0xffffffff) ^ 0x80000000) - 0x80000000;
2281 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
2282 && (hdr_info
->u
.dwarf
.array
[i
].fde
2283 != sec
->output_section
->vma
+ val
))
2285 bfd_put_32 (abfd
, val
, contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
2287 && (hdr_info
->u
.dwarf
.array
[i
].initial_loc
2288 < (hdr_info
->u
.dwarf
.array
[i
- 1].initial_loc
2289 + hdr_info
->u
.dwarf
.array
[i
- 1].range
)))
2293 (*info
->callbacks
->einfo
) (_("%P: .eh_frame_hdr entry overflow.\n"));
2295 (*info
->callbacks
->einfo
)
2296 (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2297 if (overflow
|| overlap
)
2299 bfd_set_error (bfd_error_bad_value
);
2304 /* FIXME: octets_per_byte. */
2305 if (!bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
2306 (file_ptr
) sec
->output_offset
,
2311 if (hdr_info
->u
.dwarf
.array
!= NULL
)
2312 free (hdr_info
->u
.dwarf
.array
);
2316 /* Write out .eh_frame_hdr section. This must be called after
2317 _bfd_elf_write_section_eh_frame has been called on all input
2318 .eh_frame sections. */
2321 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
2323 struct elf_link_hash_table
*htab
;
2324 struct eh_frame_hdr_info
*hdr_info
;
2327 htab
= elf_hash_table (info
);
2328 hdr_info
= &htab
->eh_info
;
2329 sec
= hdr_info
->hdr_sec
;
2331 if (info
->eh_frame_hdr_type
== 0 || sec
== NULL
)
2334 if (info
->eh_frame_hdr_type
== COMPACT_EH_HDR
)
2335 return write_compact_eh_frame_hdr (abfd
, info
);
2337 return write_dwarf_eh_frame_hdr (abfd
, info
);
2340 /* Return the width of FDE addresses. This is the default implementation. */
2343 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
2345 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
2348 /* Decide whether we can use a PC-relative encoding within the given
2349 EH frame section. This is the default implementation. */
2352 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
2353 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2354 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
2359 /* Select an encoding for the given address. Preference is given to
2360 PC-relative addressing modes. */
2363 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
2364 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2365 asection
*osec
, bfd_vma offset
,
2366 asection
*loc_sec
, bfd_vma loc_offset
,
2369 *encoded
= osec
->vma
+ offset
-
2370 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
2371 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;