1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
3 2012 Free Software Foundation, Inc.
4 Written by Jakub Jelinek <jakub@redhat.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
29 #define EH_FRAME_HDR_SIZE 8
35 unsigned char version
;
36 unsigned char local_personality
;
37 char augmentation
[20];
39 bfd_signed_vma data_align
;
41 bfd_vma augmentation_size
;
43 struct elf_link_hash_entry
*h
;
45 unsigned int reloc_index
;
48 struct eh_cie_fde
*cie_inf
;
49 unsigned char per_encoding
;
50 unsigned char lsda_encoding
;
51 unsigned char fde_encoding
;
52 unsigned char initial_insn_length
;
53 unsigned char can_make_lsda_relative
;
54 unsigned char initial_instructions
[50];
59 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
60 move onto the next byte. Return true on success. */
62 static inline bfd_boolean
63 read_byte (bfd_byte
**iter
, bfd_byte
*end
, unsigned char *result
)
67 *result
= *((*iter
)++);
71 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
72 Return true it was possible to move LENGTH bytes. */
74 static inline bfd_boolean
75 skip_bytes (bfd_byte
**iter
, bfd_byte
*end
, bfd_size_type length
)
77 if ((bfd_size_type
) (end
- *iter
) < length
)
86 /* Move *ITER over an leb128, stopping at END. Return true if the end
87 of the leb128 was found. */
90 skip_leb128 (bfd_byte
**iter
, bfd_byte
*end
)
94 if (!read_byte (iter
, end
, &byte
))
100 /* Like skip_leb128, but treat the leb128 as an unsigned value and
101 store it in *VALUE. */
104 read_uleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_vma
*value
)
109 if (!skip_leb128 (iter
, end
))
115 *value
= (*value
<< 7) | (*--p
& 0x7f);
120 /* Like read_uleb128, but for signed values. */
123 read_sleb128 (bfd_byte
**iter
, bfd_byte
*end
, bfd_signed_vma
*value
)
128 if (!skip_leb128 (iter
, end
))
132 *value
= ((*--p
& 0x7f) ^ 0x40) - 0x40;
134 *value
= (*value
<< 7) | (*--p
& 0x7f);
139 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
142 int get_DW_EH_PE_width (int encoding
, int ptr_size
)
144 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
146 if ((encoding
& 0x60) == 0x60)
149 switch (encoding
& 7)
151 case DW_EH_PE_udata2
: return 2;
152 case DW_EH_PE_udata4
: return 4;
153 case DW_EH_PE_udata8
: return 8;
154 case DW_EH_PE_absptr
: return ptr_size
;
162 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164 /* Read a width sized value from memory. */
167 read_value (bfd
*abfd
, bfd_byte
*buf
, int width
, int is_signed
)
175 value
= bfd_get_signed_16 (abfd
, buf
);
177 value
= bfd_get_16 (abfd
, buf
);
181 value
= bfd_get_signed_32 (abfd
, buf
);
183 value
= bfd_get_32 (abfd
, buf
);
187 value
= bfd_get_signed_64 (abfd
, buf
);
189 value
= bfd_get_64 (abfd
, buf
);
199 /* Store a width sized value to memory. */
202 write_value (bfd
*abfd
, bfd_byte
*buf
, bfd_vma value
, int width
)
206 case 2: bfd_put_16 (abfd
, value
, buf
); break;
207 case 4: bfd_put_32 (abfd
, value
, buf
); break;
208 case 8: bfd_put_64 (abfd
, value
, buf
); break;
209 default: BFD_FAIL ();
213 /* Return one if C1 and C2 CIEs can be merged. */
216 cie_eq (const void *e1
, const void *e2
)
218 const struct cie
*c1
= (const struct cie
*) e1
;
219 const struct cie
*c2
= (const struct cie
*) e2
;
221 if (c1
->hash
== c2
->hash
222 && c1
->length
== c2
->length
223 && c1
->version
== c2
->version
224 && c1
->local_personality
== c2
->local_personality
225 && strcmp (c1
->augmentation
, c2
->augmentation
) == 0
226 && strcmp (c1
->augmentation
, "eh") != 0
227 && c1
->code_align
== c2
->code_align
228 && c1
->data_align
== c2
->data_align
229 && c1
->ra_column
== c2
->ra_column
230 && c1
->augmentation_size
== c2
->augmentation_size
231 && memcmp (&c1
->personality
, &c2
->personality
,
232 sizeof (c1
->personality
)) == 0
233 && c1
->output_sec
== c2
->output_sec
234 && c1
->per_encoding
== c2
->per_encoding
235 && c1
->lsda_encoding
== c2
->lsda_encoding
236 && c1
->fde_encoding
== c2
->fde_encoding
237 && c1
->initial_insn_length
== c2
->initial_insn_length
238 && c1
->initial_insn_length
<= sizeof (c1
->initial_instructions
)
239 && memcmp (c1
->initial_instructions
,
240 c2
->initial_instructions
,
241 c1
->initial_insn_length
) == 0)
248 cie_hash (const void *e
)
250 const struct cie
*c
= (const struct cie
*) e
;
255 cie_compute_hash (struct cie
*c
)
259 h
= iterative_hash_object (c
->length
, h
);
260 h
= iterative_hash_object (c
->version
, h
);
261 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
262 h
= iterative_hash_object (c
->code_align
, h
);
263 h
= iterative_hash_object (c
->data_align
, h
);
264 h
= iterative_hash_object (c
->ra_column
, h
);
265 h
= iterative_hash_object (c
->augmentation_size
, h
);
266 h
= iterative_hash_object (c
->personality
, h
);
267 h
= iterative_hash_object (c
->output_sec
, h
);
268 h
= iterative_hash_object (c
->per_encoding
, h
);
269 h
= iterative_hash_object (c
->lsda_encoding
, h
);
270 h
= iterative_hash_object (c
->fde_encoding
, h
);
271 h
= iterative_hash_object (c
->initial_insn_length
, h
);
272 len
= c
->initial_insn_length
;
273 if (len
> sizeof (c
->initial_instructions
))
274 len
= sizeof (c
->initial_instructions
);
275 h
= iterative_hash (c
->initial_instructions
, len
, h
);
280 /* Return the number of extra bytes that we'll be inserting into
281 ENTRY's augmentation string. */
283 static INLINE
unsigned int
284 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
286 unsigned int size
= 0;
289 if (entry
->add_augmentation_size
)
291 if (entry
->u
.cie
.add_fde_encoding
)
297 /* Likewise ENTRY's augmentation data. */
299 static INLINE
unsigned int
300 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
302 unsigned int size
= 0;
303 if (entry
->add_augmentation_size
)
305 if (entry
->cie
&& entry
->u
.cie
.add_fde_encoding
)
310 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
311 required alignment of ENTRY in bytes. */
314 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
318 if (entry
->size
== 4)
321 + extra_augmentation_string_bytes (entry
)
322 + extra_augmentation_data_bytes (entry
)
323 + alignment
- 1) & -alignment
;
326 /* Assume that the bytes between *ITER and END are CFA instructions.
327 Try to move *ITER past the first instruction and return true on
328 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
331 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
336 if (!read_byte (iter
, end
, &op
))
339 switch (op
& 0xc0 ? op
& 0xc0 : op
)
342 case DW_CFA_advance_loc
:
344 case DW_CFA_remember_state
:
345 case DW_CFA_restore_state
:
346 case DW_CFA_GNU_window_save
:
351 case DW_CFA_restore_extended
:
352 case DW_CFA_undefined
:
353 case DW_CFA_same_value
:
354 case DW_CFA_def_cfa_register
:
355 case DW_CFA_def_cfa_offset
:
356 case DW_CFA_def_cfa_offset_sf
:
357 case DW_CFA_GNU_args_size
:
358 /* One leb128 argument. */
359 return skip_leb128 (iter
, end
);
361 case DW_CFA_val_offset
:
362 case DW_CFA_val_offset_sf
:
363 case DW_CFA_offset_extended
:
364 case DW_CFA_register
:
366 case DW_CFA_offset_extended_sf
:
367 case DW_CFA_GNU_negative_offset_extended
:
368 case DW_CFA_def_cfa_sf
:
369 /* Two leb128 arguments. */
370 return (skip_leb128 (iter
, end
)
371 && skip_leb128 (iter
, end
));
373 case DW_CFA_def_cfa_expression
:
374 /* A variable-length argument. */
375 return (read_uleb128 (iter
, end
, &length
)
376 && skip_bytes (iter
, end
, length
));
378 case DW_CFA_expression
:
379 case DW_CFA_val_expression
:
380 /* A leb128 followed by a variable-length argument. */
381 return (skip_leb128 (iter
, end
)
382 && read_uleb128 (iter
, end
, &length
)
383 && skip_bytes (iter
, end
, length
));
386 return skip_bytes (iter
, end
, encoded_ptr_width
);
388 case DW_CFA_advance_loc1
:
389 return skip_bytes (iter
, end
, 1);
391 case DW_CFA_advance_loc2
:
392 return skip_bytes (iter
, end
, 2);
394 case DW_CFA_advance_loc4
:
395 return skip_bytes (iter
, end
, 4);
397 case DW_CFA_MIPS_advance_loc8
:
398 return skip_bytes (iter
, end
, 8);
405 /* Try to interpret the bytes between BUF and END as CFA instructions.
406 If every byte makes sense, return a pointer to the first DW_CFA_nop
407 padding byte, or END if there is no padding. Return null otherwise.
408 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
411 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
412 unsigned int *set_loc_count
)
418 if (*buf
== DW_CFA_nop
)
422 if (*buf
== DW_CFA_set_loc
)
424 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
431 /* Convert absolute encoding ENCODING into PC-relative form.
432 SIZE is the size of a pointer. */
435 make_pc_relative (unsigned char encoding
, unsigned int ptr_size
)
437 if ((encoding
& 0x7f) == DW_EH_PE_absptr
)
441 encoding
|= DW_EH_PE_sdata2
;
444 encoding
|= DW_EH_PE_sdata4
;
447 encoding
|= DW_EH_PE_sdata8
;
450 return encoding
| DW_EH_PE_pcrel
;
453 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
454 .eh_frame section. */
457 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
459 struct eh_frame_hdr_info
*hdr_info
;
461 hdr_info
= &elf_hash_table (info
)->eh_info
;
462 hdr_info
->merge_cies
= !info
->relocatable
;
465 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
466 information in the section's sec_info field on success. COOKIE
467 describes the relocations in SEC. */
470 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
471 asection
*sec
, struct elf_reloc_cookie
*cookie
)
473 #define REQUIRE(COND) \
476 goto free_no_table; \
479 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
481 struct eh_cie_fde
*this_inf
;
482 unsigned int hdr_length
, hdr_id
;
483 unsigned int cie_count
;
484 struct cie
*cie
, *local_cies
= NULL
;
485 struct elf_link_hash_table
*htab
;
486 struct eh_frame_hdr_info
*hdr_info
;
487 struct eh_frame_sec_info
*sec_info
= NULL
;
488 unsigned int ptr_size
;
489 unsigned int num_cies
;
490 unsigned int num_entries
;
491 elf_gc_mark_hook_fn gc_mark_hook
;
493 htab
= elf_hash_table (info
);
494 hdr_info
= &htab
->eh_info
;
495 if (hdr_info
->parsed_eh_frames
)
499 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
501 /* This file does not contain .eh_frame information. */
505 if (bfd_is_abs_section (sec
->output_section
))
507 /* At least one of the sections is being discarded from the
508 link, so we should just ignore them. */
512 /* Read the frame unwind information from abfd. */
514 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
517 && bfd_get_32 (abfd
, ehbuf
) == 0
518 && cookie
->rel
== cookie
->relend
)
520 /* Empty .eh_frame section. */
525 /* If .eh_frame section size doesn't fit into int, we cannot handle
526 it (it would need to use 64-bit .eh_frame format anyway). */
527 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
529 ptr_size
= (get_elf_backend_data (abfd
)
530 ->elf_backend_eh_frame_address_size (abfd
, sec
));
531 REQUIRE (ptr_size
!= 0);
533 /* Go through the section contents and work out how many FDEs and
536 end
= ehbuf
+ sec
->size
;
543 /* Read the length of the entry. */
544 REQUIRE (skip_bytes (&buf
, end
, 4));
545 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
547 /* 64-bit .eh_frame is not supported. */
548 REQUIRE (hdr_length
!= 0xffffffff);
552 REQUIRE (skip_bytes (&buf
, end
, 4));
553 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
557 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
560 sec_info
= (struct eh_frame_sec_info
*)
561 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
562 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
565 /* We need to have a "struct cie" for each CIE in this section. */
566 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
567 REQUIRE (local_cies
);
569 /* FIXME: octets_per_byte. */
570 #define ENSURE_NO_RELOCS(buf) \
571 REQUIRE (!(cookie->rel < cookie->relend \
572 && (cookie->rel->r_offset \
573 < (bfd_size_type) ((buf) - ehbuf)) \
574 && cookie->rel->r_info != 0))
576 /* FIXME: octets_per_byte. */
577 #define SKIP_RELOCS(buf) \
578 while (cookie->rel < cookie->relend \
579 && (cookie->rel->r_offset \
580 < (bfd_size_type) ((buf) - ehbuf))) \
583 /* FIXME: octets_per_byte. */
584 #define GET_RELOC(buf) \
585 ((cookie->rel < cookie->relend \
586 && (cookie->rel->r_offset \
587 == (bfd_size_type) ((buf) - ehbuf))) \
588 ? cookie->rel : NULL)
592 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
593 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
596 bfd_byte
*start
, *insns
, *insns_end
;
597 bfd_size_type length
;
598 unsigned int set_loc_count
;
600 this_inf
= sec_info
->entry
+ sec_info
->count
;
603 /* Read the length of the entry. */
604 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
605 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
607 /* The CIE/FDE must be fully contained in this input section. */
608 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
609 end
= buf
+ hdr_length
;
611 this_inf
->offset
= last_fde
- ehbuf
;
612 this_inf
->size
= 4 + hdr_length
;
613 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
617 /* A zero-length CIE should only be found at the end of
619 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
620 ENSURE_NO_RELOCS (buf
);
625 REQUIRE (skip_bytes (&buf
, end
, 4));
626 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
630 unsigned int initial_insn_length
;
635 /* Point CIE to one of the section-local cie structures. */
636 cie
= local_cies
+ cie_count
++;
638 cie
->cie_inf
= this_inf
;
639 cie
->length
= hdr_length
;
640 cie
->output_sec
= sec
->output_section
;
642 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
644 /* Cannot handle unknown versions. */
645 REQUIRE (cie
->version
== 1
647 || cie
->version
== 4);
648 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
650 strcpy (cie
->augmentation
, (char *) buf
);
651 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
652 ENSURE_NO_RELOCS (buf
);
653 if (buf
[0] == 'e' && buf
[1] == 'h')
655 /* GCC < 3.0 .eh_frame CIE */
656 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
657 is private to each CIE, so we don't need it for anything.
659 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
662 if (cie
->version
>= 4)
664 REQUIRE (buf
+ 1 < end
);
665 REQUIRE (buf
[0] == ptr_size
);
666 REQUIRE (buf
[1] == 0);
669 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
670 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
671 if (cie
->version
== 1)
674 cie
->ra_column
= *buf
++;
677 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
678 ENSURE_NO_RELOCS (buf
);
679 cie
->lsda_encoding
= DW_EH_PE_omit
;
680 cie
->fde_encoding
= DW_EH_PE_omit
;
681 cie
->per_encoding
= DW_EH_PE_omit
;
682 aug
= cie
->augmentation
;
683 if (aug
[0] != 'e' || aug
[1] != 'h')
688 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
689 ENSURE_NO_RELOCS (buf
);
696 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
697 ENSURE_NO_RELOCS (buf
);
698 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
701 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
702 ENSURE_NO_RELOCS (buf
);
703 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
711 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
712 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
715 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
717 length
= -(buf
- ehbuf
) & (per_width
- 1);
718 REQUIRE (skip_bytes (&buf
, end
, length
));
720 this_inf
->u
.cie
.personality_offset
= buf
- start
;
721 ENSURE_NO_RELOCS (buf
);
722 /* Ensure we have a reloc here. */
723 REQUIRE (GET_RELOC (buf
));
724 cie
->personality
.reloc_index
725 = cookie
->rel
- cookie
->rels
;
726 /* Cope with MIPS-style composite relocations. */
729 while (GET_RELOC (buf
) != NULL
);
730 REQUIRE (skip_bytes (&buf
, end
, per_width
));
734 /* Unrecognized augmentation. Better bail out. */
739 /* For shared libraries, try to get rid of as many RELATIVE relocs
742 && (get_elf_backend_data (abfd
)
743 ->elf_backend_can_make_relative_eh_frame
746 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
747 this_inf
->make_relative
= 1;
748 /* If the CIE doesn't already have an 'R' entry, it's fairly
749 easy to add one, provided that there's no aligned data
750 after the augmentation string. */
751 else if (cie
->fde_encoding
== DW_EH_PE_omit
752 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
754 if (*cie
->augmentation
== 0)
755 this_inf
->add_augmentation_size
= 1;
756 this_inf
->u
.cie
.add_fde_encoding
= 1;
757 this_inf
->make_relative
= 1;
760 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
761 cie
->can_make_lsda_relative
= 1;
764 /* If FDE encoding was not specified, it defaults to
766 if (cie
->fde_encoding
== DW_EH_PE_omit
)
767 cie
->fde_encoding
= DW_EH_PE_absptr
;
769 initial_insn_length
= end
- buf
;
770 cie
->initial_insn_length
= initial_insn_length
;
771 memcpy (cie
->initial_instructions
, buf
,
772 initial_insn_length
<= sizeof (cie
->initial_instructions
)
773 ? initial_insn_length
: sizeof (cie
->initial_instructions
));
775 buf
+= initial_insn_length
;
776 ENSURE_NO_RELOCS (buf
);
778 if (hdr_info
->merge_cies
)
779 this_inf
->u
.cie
.u
.full_cie
= cie
;
780 this_inf
->u
.cie
.per_encoding_relative
781 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
785 /* Find the corresponding CIE. */
786 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
787 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
788 if (cie_offset
== cie
->cie_inf
->offset
)
791 /* Ensure this FDE references one of the CIEs in this input
793 REQUIRE (cie
!= local_cies
+ cie_count
);
794 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
795 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
796 this_inf
->add_augmentation_size
797 = cie
->cie_inf
->add_augmentation_size
;
799 ENSURE_NO_RELOCS (buf
);
800 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
804 REQUIRE (GET_RELOC (buf
));
806 /* Chain together the FDEs for each section. */
807 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
808 /* RSEC will be NULL if FDE was cleared out as it was belonging to
809 a discarded SHT_GROUP. */
812 REQUIRE (rsec
->owner
== abfd
);
813 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
814 elf_fde_list (rsec
) = this_inf
;
818 /* Skip the initial location and address range. */
820 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
821 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
823 /* Skip the augmentation size, if present. */
824 if (cie
->augmentation
[0] == 'z')
825 REQUIRE (read_uleb128 (&buf
, end
, &length
));
829 /* Of the supported augmentation characters above, only 'L'
830 adds augmentation data to the FDE. This code would need to
831 be adjusted if any future augmentations do the same thing. */
832 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
835 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
836 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
837 this_inf
->lsda_offset
= buf
- start
;
838 /* If there's no 'z' augmentation, we don't know where the
839 CFA insns begin. Assume no padding. */
840 if (cie
->augmentation
[0] != 'z')
844 /* Skip over the augmentation data. */
845 REQUIRE (skip_bytes (&buf
, end
, length
));
848 buf
= last_fde
+ 4 + hdr_length
;
850 /* For NULL RSEC (cleared FDE belonging to a discarded section)
851 the relocations are commonly cleared. We do not sanity check if
852 all these relocations are cleared as (1) relocations to
853 .gcc_except_table will remain uncleared (they will get dropped
854 with the drop of this unused FDE) and (2) BFD already safely drops
855 relocations of any type to .eh_frame by
856 elf_section_ignore_discarded_relocs.
857 TODO: The .gcc_except_table entries should be also filtered as
858 .eh_frame entries; or GCC could rather use COMDAT for them. */
862 /* Try to interpret the CFA instructions and find the first
863 padding nop. Shrink this_inf's size so that it doesn't
864 include the padding. */
865 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
867 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
868 /* If we don't understand the CFA instructions, we can't know
869 what needs to be adjusted there. */
870 if (insns_end
== NULL
871 /* For the time being we don't support DW_CFA_set_loc in
873 || (set_loc_count
&& this_inf
->cie
))
875 this_inf
->size
-= end
- insns_end
;
876 if (insns_end
!= end
&& this_inf
->cie
)
878 cie
->initial_insn_length
-= end
- insns_end
;
879 cie
->length
-= end
- insns_end
;
882 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
883 || this_inf
->make_relative
))
888 this_inf
->set_loc
= (unsigned int *)
889 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
890 REQUIRE (this_inf
->set_loc
);
891 this_inf
->set_loc
[0] = set_loc_count
;
896 if (*p
== DW_CFA_set_loc
)
897 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
898 REQUIRE (skip_cfa_op (&p
, end
, length
));
902 this_inf
->removed
= 1;
903 this_inf
->fde_encoding
= cie
->fde_encoding
;
904 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
907 BFD_ASSERT (sec_info
->count
== num_entries
);
908 BFD_ASSERT (cie_count
== num_cies
);
910 elf_section_data (sec
)->sec_info
= sec_info
;
911 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
912 if (hdr_info
->merge_cies
)
914 sec_info
->cies
= local_cies
;
920 (*info
->callbacks
->einfo
)
921 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
923 hdr_info
->table
= FALSE
;
934 /* Finish a pass over all .eh_frame sections. */
937 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
939 struct eh_frame_hdr_info
*hdr_info
;
941 hdr_info
= &elf_hash_table (info
)->eh_info
;
942 hdr_info
->parsed_eh_frames
= TRUE
;
945 /* Mark all relocations against CIE or FDE ENT, which occurs in
946 .eh_frame section SEC. COOKIE describes the relocations in SEC;
947 its "rel" field can be changed freely. */
950 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
951 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
952 struct elf_reloc_cookie
*cookie
)
954 /* FIXME: octets_per_byte. */
955 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
956 cookie
->rel
< cookie
->relend
957 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
959 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
965 /* Mark all the relocations against FDEs that relate to code in input
966 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
967 relocations are described by COOKIE. */
970 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
971 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
972 struct elf_reloc_cookie
*cookie
)
974 struct eh_cie_fde
*fde
, *cie
;
976 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
978 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
981 /* At this stage, all cie_inf fields point to local CIEs, so we
982 can use the same cookie to refer to them. */
983 cie
= fde
->u
.fde
.cie_inf
;
984 if (!cie
->u
.cie
.gc_mark
)
986 cie
->u
.cie
.gc_mark
= 1;
987 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
994 /* Input section SEC of ABFD is an .eh_frame section that contains the
995 CIE described by CIE_INF. Return a version of CIE_INF that is going
996 to be kept in the output, adding CIE_INF to the output if necessary.
998 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
999 relocations in REL. */
1001 static struct eh_cie_fde
*
1002 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1003 struct eh_frame_hdr_info
*hdr_info
,
1004 struct elf_reloc_cookie
*cookie
,
1005 struct eh_cie_fde
*cie_inf
)
1007 unsigned long r_symndx
;
1008 struct cie
*cie
, *new_cie
;
1009 Elf_Internal_Rela
*rel
;
1012 /* Use CIE_INF if we have already decided to keep it. */
1013 if (!cie_inf
->removed
)
1016 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1017 if (cie_inf
->u
.cie
.merged
)
1018 return cie_inf
->u
.cie
.u
.merged_with
;
1020 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1022 /* Assume we will need to keep CIE_INF. */
1023 cie_inf
->removed
= 0;
1024 cie_inf
->u
.cie
.u
.sec
= sec
;
1026 /* If we are not merging CIEs, use CIE_INF. */
1030 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1032 bfd_boolean per_binds_local
;
1034 /* Work out the address of personality routine, either as an absolute
1035 value or as a symbol. */
1036 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1037 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1039 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1040 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1043 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1044 if (r_symndx
>= cookie
->locsymcount
1045 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1047 struct elf_link_hash_entry
*h
;
1049 r_symndx
-= cookie
->extsymoff
;
1050 h
= cookie
->sym_hashes
[r_symndx
];
1052 while (h
->root
.type
== bfd_link_hash_indirect
1053 || h
->root
.type
== bfd_link_hash_warning
)
1054 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1056 cie
->personality
.h
= h
;
1057 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1061 Elf_Internal_Sym
*sym
;
1064 sym
= &cookie
->locsyms
[r_symndx
];
1065 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1066 if (sym_sec
== NULL
)
1069 if (sym_sec
->kept_section
!= NULL
)
1070 sym_sec
= sym_sec
->kept_section
;
1071 if (sym_sec
->output_section
== NULL
)
1074 cie
->local_personality
= 1;
1075 cie
->personality
.val
= (sym
->st_value
1076 + sym_sec
->output_offset
1077 + sym_sec
->output_section
->vma
);
1078 per_binds_local
= TRUE
;
1083 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1084 && (get_elf_backend_data (abfd
)
1085 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1087 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1088 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1092 /* See if we can merge this CIE with an earlier one. */
1093 cie
->output_sec
= sec
->output_section
;
1094 cie_compute_hash (cie
);
1095 if (hdr_info
->cies
== NULL
)
1097 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1098 if (hdr_info
->cies
== NULL
)
1101 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
, cie
->hash
, INSERT
);
1105 new_cie
= (struct cie
*) *loc
;
1106 if (new_cie
== NULL
)
1108 /* Keep CIE_INF and record it in the hash table. */
1109 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1110 if (new_cie
== NULL
)
1113 memcpy (new_cie
, cie
, sizeof (struct cie
));
1118 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1119 cie_inf
->removed
= 1;
1120 cie_inf
->u
.cie
.merged
= 1;
1121 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1122 if (cie_inf
->u
.cie
.make_lsda_relative
)
1123 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1125 return new_cie
->cie_inf
;
1128 /* This function is called for each input file before the .eh_frame
1129 section is relocated. It discards duplicate CIEs and FDEs for discarded
1130 functions. The function returns TRUE iff any entries have been
1134 _bfd_elf_discard_section_eh_frame
1135 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1136 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1137 struct elf_reloc_cookie
*cookie
)
1139 struct eh_cie_fde
*ent
;
1140 struct eh_frame_sec_info
*sec_info
;
1141 struct eh_frame_hdr_info
*hdr_info
;
1142 unsigned int ptr_size
, offset
;
1144 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1147 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1148 if (sec_info
== NULL
)
1151 ptr_size
= (get_elf_backend_data (sec
->owner
)
1152 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1154 hdr_info
= &elf_hash_table (info
)->eh_info
;
1155 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1157 /* There should only be one zero terminator, on the last input
1158 file supplying .eh_frame (crtend.o). Remove any others. */
1159 ent
->removed
= sec
->map_head
.s
!= NULL
;
1163 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1166 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1168 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1169 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1174 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1175 /* FIXME: octets_per_byte. */
1176 BFD_ASSERT (cookie
->rel
< cookie
->relend
1177 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1178 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1183 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1184 && ent
->make_relative
== 0)
1185 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1187 /* If a shared library uses absolute pointers
1188 which we cannot turn into PC relative,
1189 don't create the binary search table,
1190 since it is affected by runtime relocations. */
1191 hdr_info
->table
= FALSE
;
1192 (*info
->callbacks
->einfo
)
1193 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1194 " table being created.\n"), abfd
, sec
);
1197 hdr_info
->fde_count
++;
1198 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1199 cookie
, ent
->u
.fde
.cie_inf
);
1205 free (sec_info
->cies
);
1206 sec_info
->cies
= NULL
;
1210 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1213 ent
->new_offset
= offset
;
1214 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1217 sec
->rawsize
= sec
->size
;
1219 return offset
!= sec
->rawsize
;
1222 /* This function is called for .eh_frame_hdr section after
1223 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1224 input sections. It finalizes the size of .eh_frame_hdr section. */
1227 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1229 struct elf_link_hash_table
*htab
;
1230 struct eh_frame_hdr_info
*hdr_info
;
1233 htab
= elf_hash_table (info
);
1234 hdr_info
= &htab
->eh_info
;
1236 if (hdr_info
->cies
!= NULL
)
1238 htab_delete (hdr_info
->cies
);
1239 hdr_info
->cies
= NULL
;
1242 sec
= hdr_info
->hdr_sec
;
1246 sec
->size
= EH_FRAME_HDR_SIZE
;
1247 if (hdr_info
->table
)
1248 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1250 elf_eh_frame_hdr (abfd
) = sec
;
1254 /* Return true if there is at least one non-empty .eh_frame section in
1255 input files. Can only be called after ld has mapped input to
1256 output sections, and before sections are stripped. */
1258 _bfd_elf_eh_frame_present (struct bfd_link_info
*info
)
1260 asection
*eh
= bfd_get_section_by_name (info
->output_bfd
, ".eh_frame");
1265 /* Count only sections which have at least a single CIE or FDE.
1266 There cannot be any CIE or FDE <= 8 bytes. */
1267 for (eh
= eh
->map_head
.s
; eh
!= NULL
; eh
= eh
->map_head
.s
)
1274 /* This function is called from size_dynamic_sections.
1275 It needs to decide whether .eh_frame_hdr should be output or not,
1276 because when the dynamic symbol table has been sized it is too late
1277 to strip sections. */
1280 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1282 struct elf_link_hash_table
*htab
;
1283 struct eh_frame_hdr_info
*hdr_info
;
1285 htab
= elf_hash_table (info
);
1286 hdr_info
= &htab
->eh_info
;
1287 if (hdr_info
->hdr_sec
== NULL
)
1290 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
)
1291 || !info
->eh_frame_hdr
1292 || !_bfd_elf_eh_frame_present (info
))
1294 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1295 hdr_info
->hdr_sec
= NULL
;
1299 hdr_info
->table
= TRUE
;
1303 /* Adjust an address in the .eh_frame section. Given OFFSET within
1304 SEC, this returns the new offset in the adjusted .eh_frame section,
1305 or -1 if the address refers to a CIE/FDE which has been removed
1306 or to offset with dynamic relocation which is no longer needed. */
1309 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1310 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1314 struct eh_frame_sec_info
*sec_info
;
1315 unsigned int lo
, hi
, mid
;
1317 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1319 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1321 if (offset
>= sec
->rawsize
)
1322 return offset
- sec
->rawsize
+ sec
->size
;
1325 hi
= sec_info
->count
;
1329 mid
= (lo
+ hi
) / 2;
1330 if (offset
< sec_info
->entry
[mid
].offset
)
1333 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1339 BFD_ASSERT (lo
< hi
);
1341 /* FDE or CIE was removed. */
1342 if (sec_info
->entry
[mid
].removed
)
1343 return (bfd_vma
) -1;
1345 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1346 no need for run-time relocation against the personality field. */
1347 if (sec_info
->entry
[mid
].cie
1348 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1349 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1350 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1351 return (bfd_vma
) -2;
1353 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1354 relocation against FDE's initial_location field. */
1355 if (!sec_info
->entry
[mid
].cie
1356 && sec_info
->entry
[mid
].make_relative
1357 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1358 return (bfd_vma
) -2;
1360 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1361 for run-time relocation against LSDA field. */
1362 if (!sec_info
->entry
[mid
].cie
1363 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1364 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1365 + sec_info
->entry
[mid
].lsda_offset
))
1366 return (bfd_vma
) -2;
1368 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1369 relocation against DW_CFA_set_loc's arguments. */
1370 if (sec_info
->entry
[mid
].set_loc
1371 && sec_info
->entry
[mid
].make_relative
1372 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1373 + sec_info
->entry
[mid
].set_loc
[1]))
1377 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1378 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1379 + sec_info
->entry
[mid
].set_loc
[cnt
])
1380 return (bfd_vma
) -2;
1383 /* Any new augmentation bytes go before the first relocation. */
1384 return (offset
+ sec_info
->entry
[mid
].new_offset
1385 - sec_info
->entry
[mid
].offset
1386 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1387 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1390 /* Write out .eh_frame section. This is called with the relocated
1394 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1395 struct bfd_link_info
*info
,
1399 struct eh_frame_sec_info
*sec_info
;
1400 struct elf_link_hash_table
*htab
;
1401 struct eh_frame_hdr_info
*hdr_info
;
1402 unsigned int ptr_size
;
1403 struct eh_cie_fde
*ent
;
1405 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1406 /* FIXME: octets_per_byte. */
1407 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1408 sec
->output_offset
, sec
->size
);
1410 ptr_size
= (get_elf_backend_data (abfd
)
1411 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1412 BFD_ASSERT (ptr_size
!= 0);
1414 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1415 htab
= elf_hash_table (info
);
1416 hdr_info
= &htab
->eh_info
;
1418 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1419 hdr_info
->array
= (struct eh_frame_array_ent
*)
1420 bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1421 if (hdr_info
->array
== NULL
)
1424 /* The new offsets can be bigger or smaller than the original offsets.
1425 We therefore need to make two passes over the section: one backward
1426 pass to move entries up and one forward pass to move entries down.
1427 The two passes won't interfere with each other because entries are
1429 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1430 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1431 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1433 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1434 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1435 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1437 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1439 unsigned char *buf
, *end
;
1440 unsigned int new_size
;
1447 /* Any terminating FDE must be at the end of the section. */
1448 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1452 buf
= contents
+ ent
->new_offset
;
1453 end
= buf
+ ent
->size
;
1454 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1456 /* Update the size. It may be shrinked. */
1457 bfd_put_32 (abfd
, new_size
- 4, buf
);
1459 /* Filling the extra bytes with DW_CFA_nops. */
1460 if (new_size
!= ent
->size
)
1461 memset (end
, 0, new_size
- ent
->size
);
1466 if (ent
->make_relative
1467 || ent
->u
.cie
.make_lsda_relative
1468 || ent
->u
.cie
.per_encoding_relative
)
1471 unsigned int action
, extra_string
, extra_data
;
1472 unsigned int per_width
, per_encoding
;
1474 /* Need to find 'R' or 'L' augmentation's argument and modify
1475 DW_EH_PE_* value. */
1476 action
= ((ent
->make_relative
? 1 : 0)
1477 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1478 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1479 extra_string
= extra_augmentation_string_bytes (ent
);
1480 extra_data
= extra_augmentation_data_bytes (ent
);
1482 /* Skip length, id and version. */
1485 buf
+= strlen (aug
) + 1;
1486 skip_leb128 (&buf
, end
);
1487 skip_leb128 (&buf
, end
);
1488 skip_leb128 (&buf
, end
);
1491 /* The uleb128 will always be a single byte for the kind
1492 of augmentation strings that we're prepared to handle. */
1493 *buf
++ += extra_data
;
1497 /* Make room for the new augmentation string and data bytes. */
1498 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1499 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1500 buf
+= extra_string
;
1501 end
+= extra_string
+ extra_data
;
1503 if (ent
->add_augmentation_size
)
1506 *buf
++ = extra_data
- 1;
1508 if (ent
->u
.cie
.add_fde_encoding
)
1510 BFD_ASSERT (action
& 1);
1512 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
1522 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1523 *buf
= make_pc_relative (*buf
, ptr_size
);
1529 if (ent
->u
.cie
.make_per_encoding_relative
)
1530 *buf
= make_pc_relative (*buf
, ptr_size
);
1531 per_encoding
= *buf
++;
1532 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1533 BFD_ASSERT (per_width
!= 0);
1534 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1535 == ent
->u
.cie
.per_encoding_relative
);
1536 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
1538 + ((buf
- contents
+ per_width
- 1)
1539 & ~((bfd_size_type
) per_width
- 1)));
1544 val
= read_value (abfd
, buf
, per_width
,
1545 get_DW_EH_PE_signed (per_encoding
));
1546 if (ent
->u
.cie
.make_per_encoding_relative
)
1547 val
-= (sec
->output_section
->vma
1548 + sec
->output_offset
1549 + (buf
- contents
));
1552 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1553 val
-= extra_string
+ extra_data
;
1555 write_value (abfd
, buf
, val
, per_width
);
1563 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1564 *buf
= make_pc_relative (*buf
, ptr_size
);
1579 bfd_vma value
, address
;
1582 struct eh_cie_fde
*cie
;
1585 cie
= ent
->u
.fde
.cie_inf
;
1587 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1588 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1589 bfd_put_32 (abfd
, value
, buf
);
1591 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1592 value
= read_value (abfd
, buf
, width
,
1593 get_DW_EH_PE_signed (ent
->fde_encoding
));
1597 switch (ent
->fde_encoding
& 0x70)
1599 case DW_EH_PE_textrel
:
1600 BFD_ASSERT (hdr_info
== NULL
);
1602 case DW_EH_PE_datarel
:
1604 switch (abfd
->arch_info
->arch
)
1607 BFD_ASSERT (elf_gp (abfd
) != 0);
1608 address
+= elf_gp (abfd
);
1611 (*info
->callbacks
->einfo
)
1612 (_("%P: DW_EH_PE_datarel unspecified"
1613 " for this architecture.\n"));
1617 BFD_ASSERT (htab
->hgot
!= NULL
1618 && ((htab
->hgot
->root
.type
1619 == bfd_link_hash_defined
)
1620 || (htab
->hgot
->root
.type
1621 == bfd_link_hash_defweak
)));
1623 += (htab
->hgot
->root
.u
.def
.value
1624 + htab
->hgot
->root
.u
.def
.section
->output_offset
1625 + (htab
->hgot
->root
.u
.def
.section
->output_section
1631 case DW_EH_PE_pcrel
:
1632 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1633 address
+= (sec
->output_section
->vma
1634 + sec
->output_offset
1638 if (ent
->make_relative
)
1639 value
-= (sec
->output_section
->vma
1640 + sec
->output_offset
1641 + ent
->new_offset
+ 8);
1642 write_value (abfd
, buf
, value
, width
);
1649 /* The address calculation may overflow, giving us a
1650 value greater than 4G on a 32-bit target when
1651 dwarf_vma is 64-bit. */
1652 if (sizeof (address
) > 4 && ptr_size
== 4)
1653 address
&= 0xffffffff;
1654 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1655 hdr_info
->array
[hdr_info
->array_count
++].fde
1656 = (sec
->output_section
->vma
1657 + sec
->output_offset
1661 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
1662 || cie
->u
.cie
.make_lsda_relative
)
1664 buf
+= ent
->lsda_offset
;
1665 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1666 value
= read_value (abfd
, buf
, width
,
1667 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1670 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1671 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1672 else if (cie
->u
.cie
.make_lsda_relative
)
1673 value
-= (sec
->output_section
->vma
1674 + sec
->output_offset
1675 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1676 write_value (abfd
, buf
, value
, width
);
1679 else if (ent
->add_augmentation_size
)
1681 /* Skip the PC and length and insert a zero byte for the
1682 augmentation size. */
1684 memmove (buf
+ 1, buf
, end
- buf
);
1690 /* Adjust DW_CFA_set_loc. */
1694 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1695 new_offset
= ent
->new_offset
+ 8
1696 + extra_augmentation_string_bytes (ent
)
1697 + extra_augmentation_data_bytes (ent
);
1699 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1701 buf
= start
+ ent
->set_loc
[cnt
];
1703 value
= read_value (abfd
, buf
, width
,
1704 get_DW_EH_PE_signed (ent
->fde_encoding
));
1708 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
1709 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
1710 if (ent
->make_relative
)
1711 value
-= (sec
->output_section
->vma
1712 + sec
->output_offset
1713 + new_offset
+ ent
->set_loc
[cnt
]);
1714 write_value (abfd
, buf
, value
, width
);
1720 /* We don't align the section to its section alignment since the
1721 runtime library only expects all CIE/FDE records aligned at
1722 the pointer size. _bfd_elf_discard_section_eh_frame should
1723 have padded CIE/FDE records to multiple of pointer size with
1724 size_of_output_cie_fde. */
1725 if ((sec
->size
% ptr_size
) != 0)
1728 /* FIXME: octets_per_byte. */
1729 return bfd_set_section_contents (abfd
, sec
->output_section
,
1730 contents
, (file_ptr
) sec
->output_offset
,
1734 /* Helper function used to sort .eh_frame_hdr search table by increasing
1735 VMA of FDE initial location. */
1738 vma_compare (const void *a
, const void *b
)
1740 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
1741 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
1742 if (p
->initial_loc
> q
->initial_loc
)
1744 if (p
->initial_loc
< q
->initial_loc
)
1749 /* Write out .eh_frame_hdr section. This must be called after
1750 _bfd_elf_write_section_eh_frame has been called on all input
1752 .eh_frame_hdr format:
1753 ubyte version (currently 1)
1754 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1756 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1757 number (or DW_EH_PE_omit if there is no
1758 binary search table computed))
1759 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1760 or DW_EH_PE_omit if not present.
1761 DW_EH_PE_datarel is using address of
1762 .eh_frame_hdr section start as base)
1763 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1764 optionally followed by:
1765 [encoded] fde_count (total number of FDEs in .eh_frame section)
1766 fde_count x [encoded] initial_loc, fde
1767 (array of encoded pairs containing
1768 FDE initial_location field and FDE address,
1769 sorted by increasing initial_loc). */
1772 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1774 struct elf_link_hash_table
*htab
;
1775 struct eh_frame_hdr_info
*hdr_info
;
1777 bfd_boolean retval
= TRUE
;
1779 htab
= elf_hash_table (info
);
1780 hdr_info
= &htab
->eh_info
;
1781 sec
= hdr_info
->hdr_sec
;
1783 if (info
->eh_frame_hdr
&& sec
!= NULL
)
1786 asection
*eh_frame_sec
;
1788 bfd_vma encoded_eh_frame
;
1790 size
= EH_FRAME_HDR_SIZE
;
1791 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1792 size
+= 4 + hdr_info
->fde_count
* 8;
1793 contents
= (bfd_byte
*) bfd_malloc (size
);
1794 if (contents
== NULL
)
1797 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1798 if (eh_frame_sec
== NULL
)
1804 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1807 /* .eh_frame offset. */
1808 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1809 (abfd
, info
, eh_frame_sec
, 0, sec
, 4, &encoded_eh_frame
);
1811 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1813 /* FDE count encoding. */
1814 contents
[2] = DW_EH_PE_udata4
;
1815 /* Search table encoding. */
1816 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
1820 contents
[2] = DW_EH_PE_omit
;
1821 contents
[3] = DW_EH_PE_omit
;
1823 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1825 if (contents
[2] != DW_EH_PE_omit
)
1829 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1830 qsort (hdr_info
->array
, hdr_info
->fde_count
,
1831 sizeof (*hdr_info
->array
), vma_compare
);
1832 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1835 hdr_info
->array
[i
].initial_loc
1836 - sec
->output_section
->vma
,
1837 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1839 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1840 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1844 /* FIXME: octets_per_byte. */
1845 retval
= bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1846 (file_ptr
) sec
->output_offset
,
1850 if (hdr_info
->array
!= NULL
)
1851 free (hdr_info
->array
);
1855 /* Return the width of FDE addresses. This is the default implementation. */
1858 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1860 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1863 /* Decide whether we can use a PC-relative encoding within the given
1864 EH frame section. This is the default implementation. */
1867 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1868 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1869 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1874 /* Select an encoding for the given address. Preference is given to
1875 PC-relative addressing modes. */
1878 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1879 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1880 asection
*osec
, bfd_vma offset
,
1881 asection
*loc_sec
, bfd_vma loc_offset
,
1884 *encoded
= osec
->vma
+ offset
-
1885 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1886 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;