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 && memcmp (c1
->initial_instructions
,
239 c2
->initial_instructions
,
240 c1
->initial_insn_length
) == 0)
247 cie_hash (const void *e
)
249 const struct cie
*c
= (const struct cie
*) e
;
254 cie_compute_hash (struct cie
*c
)
257 h
= iterative_hash_object (c
->length
, h
);
258 h
= iterative_hash_object (c
->version
, h
);
259 h
= iterative_hash (c
->augmentation
, strlen (c
->augmentation
) + 1, h
);
260 h
= iterative_hash_object (c
->code_align
, h
);
261 h
= iterative_hash_object (c
->data_align
, h
);
262 h
= iterative_hash_object (c
->ra_column
, h
);
263 h
= iterative_hash_object (c
->augmentation_size
, h
);
264 h
= iterative_hash_object (c
->personality
, h
);
265 h
= iterative_hash_object (c
->output_sec
, h
);
266 h
= iterative_hash_object (c
->per_encoding
, h
);
267 h
= iterative_hash_object (c
->lsda_encoding
, h
);
268 h
= iterative_hash_object (c
->fde_encoding
, h
);
269 h
= iterative_hash_object (c
->initial_insn_length
, h
);
270 h
= iterative_hash (c
->initial_instructions
, c
->initial_insn_length
, h
);
275 /* Return the number of extra bytes that we'll be inserting into
276 ENTRY's augmentation string. */
278 static INLINE
unsigned int
279 extra_augmentation_string_bytes (struct eh_cie_fde
*entry
)
281 unsigned int size
= 0;
284 if (entry
->add_augmentation_size
)
286 if (entry
->u
.cie
.add_fde_encoding
)
292 /* Likewise ENTRY's augmentation data. */
294 static INLINE
unsigned int
295 extra_augmentation_data_bytes (struct eh_cie_fde
*entry
)
297 unsigned int size
= 0;
298 if (entry
->add_augmentation_size
)
300 if (entry
->cie
&& entry
->u
.cie
.add_fde_encoding
)
305 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
306 required alignment of ENTRY in bytes. */
309 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
313 if (entry
->size
== 4)
316 + extra_augmentation_string_bytes (entry
)
317 + extra_augmentation_data_bytes (entry
)
318 + alignment
- 1) & -alignment
;
321 /* Assume that the bytes between *ITER and END are CFA instructions.
322 Try to move *ITER past the first instruction and return true on
323 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
326 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
331 if (!read_byte (iter
, end
, &op
))
334 switch (op
& 0xc0 ? op
& 0xc0 : op
)
337 case DW_CFA_advance_loc
:
339 case DW_CFA_remember_state
:
340 case DW_CFA_restore_state
:
341 case DW_CFA_GNU_window_save
:
346 case DW_CFA_restore_extended
:
347 case DW_CFA_undefined
:
348 case DW_CFA_same_value
:
349 case DW_CFA_def_cfa_register
:
350 case DW_CFA_def_cfa_offset
:
351 case DW_CFA_def_cfa_offset_sf
:
352 case DW_CFA_GNU_args_size
:
353 /* One leb128 argument. */
354 return skip_leb128 (iter
, end
);
356 case DW_CFA_val_offset
:
357 case DW_CFA_val_offset_sf
:
358 case DW_CFA_offset_extended
:
359 case DW_CFA_register
:
361 case DW_CFA_offset_extended_sf
:
362 case DW_CFA_GNU_negative_offset_extended
:
363 case DW_CFA_def_cfa_sf
:
364 /* Two leb128 arguments. */
365 return (skip_leb128 (iter
, end
)
366 && skip_leb128 (iter
, end
));
368 case DW_CFA_def_cfa_expression
:
369 /* A variable-length argument. */
370 return (read_uleb128 (iter
, end
, &length
)
371 && skip_bytes (iter
, end
, length
));
373 case DW_CFA_expression
:
374 case DW_CFA_val_expression
:
375 /* A leb128 followed by a variable-length argument. */
376 return (skip_leb128 (iter
, end
)
377 && read_uleb128 (iter
, end
, &length
)
378 && skip_bytes (iter
, end
, length
));
381 return skip_bytes (iter
, end
, encoded_ptr_width
);
383 case DW_CFA_advance_loc1
:
384 return skip_bytes (iter
, end
, 1);
386 case DW_CFA_advance_loc2
:
387 return skip_bytes (iter
, end
, 2);
389 case DW_CFA_advance_loc4
:
390 return skip_bytes (iter
, end
, 4);
392 case DW_CFA_MIPS_advance_loc8
:
393 return skip_bytes (iter
, end
, 8);
400 /* Try to interpret the bytes between BUF and END as CFA instructions.
401 If every byte makes sense, return a pointer to the first DW_CFA_nop
402 padding byte, or END if there is no padding. Return null otherwise.
403 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
406 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
407 unsigned int *set_loc_count
)
413 if (*buf
== DW_CFA_nop
)
417 if (*buf
== DW_CFA_set_loc
)
419 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
426 /* Convert absolute encoding ENCODING into PC-relative form.
427 SIZE is the size of a pointer. */
430 make_pc_relative (unsigned char encoding
, unsigned int ptr_size
)
432 if ((encoding
& 0x7f) == DW_EH_PE_absptr
)
436 encoding
|= DW_EH_PE_sdata2
;
439 encoding
|= DW_EH_PE_sdata4
;
442 encoding
|= DW_EH_PE_sdata8
;
445 return encoding
| DW_EH_PE_pcrel
;
448 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
449 .eh_frame section. */
452 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
454 struct eh_frame_hdr_info
*hdr_info
;
456 hdr_info
= &elf_hash_table (info
)->eh_info
;
457 hdr_info
->merge_cies
= !info
->relocatable
;
460 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
461 information in the section's sec_info field on success. COOKIE
462 describes the relocations in SEC. */
465 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
466 asection
*sec
, struct elf_reloc_cookie
*cookie
)
468 #define REQUIRE(COND) \
471 goto free_no_table; \
474 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
476 struct eh_cie_fde
*this_inf
;
477 unsigned int hdr_length
, hdr_id
;
478 unsigned int cie_count
;
479 struct cie
*cie
, *local_cies
= NULL
;
480 struct elf_link_hash_table
*htab
;
481 struct eh_frame_hdr_info
*hdr_info
;
482 struct eh_frame_sec_info
*sec_info
= NULL
;
483 unsigned int ptr_size
;
484 unsigned int num_cies
;
485 unsigned int num_entries
;
486 elf_gc_mark_hook_fn gc_mark_hook
;
488 htab
= elf_hash_table (info
);
489 hdr_info
= &htab
->eh_info
;
490 if (hdr_info
->parsed_eh_frames
)
494 || sec
->sec_info_type
!= SEC_INFO_TYPE_NONE
)
496 /* This file does not contain .eh_frame information. */
500 if (bfd_is_abs_section (sec
->output_section
))
502 /* At least one of the sections is being discarded from the
503 link, so we should just ignore them. */
507 /* Read the frame unwind information from abfd. */
509 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
512 && bfd_get_32 (abfd
, ehbuf
) == 0
513 && cookie
->rel
== cookie
->relend
)
515 /* Empty .eh_frame section. */
520 /* If .eh_frame section size doesn't fit into int, we cannot handle
521 it (it would need to use 64-bit .eh_frame format anyway). */
522 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
524 ptr_size
= (get_elf_backend_data (abfd
)
525 ->elf_backend_eh_frame_address_size (abfd
, sec
));
526 REQUIRE (ptr_size
!= 0);
528 /* Go through the section contents and work out how many FDEs and
531 end
= ehbuf
+ sec
->size
;
538 /* Read the length of the entry. */
539 REQUIRE (skip_bytes (&buf
, end
, 4));
540 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
542 /* 64-bit .eh_frame is not supported. */
543 REQUIRE (hdr_length
!= 0xffffffff);
547 REQUIRE (skip_bytes (&buf
, end
, 4));
548 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
552 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
555 sec_info
= (struct eh_frame_sec_info
*)
556 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
557 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
560 /* We need to have a "struct cie" for each CIE in this section. */
561 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
562 REQUIRE (local_cies
);
564 /* FIXME: octets_per_byte. */
565 #define ENSURE_NO_RELOCS(buf) \
566 REQUIRE (!(cookie->rel < cookie->relend \
567 && (cookie->rel->r_offset \
568 < (bfd_size_type) ((buf) - ehbuf)) \
569 && cookie->rel->r_info != 0))
571 /* FIXME: octets_per_byte. */
572 #define SKIP_RELOCS(buf) \
573 while (cookie->rel < cookie->relend \
574 && (cookie->rel->r_offset \
575 < (bfd_size_type) ((buf) - ehbuf))) \
578 /* FIXME: octets_per_byte. */
579 #define GET_RELOC(buf) \
580 ((cookie->rel < cookie->relend \
581 && (cookie->rel->r_offset \
582 == (bfd_size_type) ((buf) - ehbuf))) \
583 ? cookie->rel : NULL)
587 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
588 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
591 bfd_byte
*start
, *insns
, *insns_end
;
592 bfd_size_type length
;
593 unsigned int set_loc_count
;
595 this_inf
= sec_info
->entry
+ sec_info
->count
;
598 /* Read the length of the entry. */
599 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
600 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
602 /* The CIE/FDE must be fully contained in this input section. */
603 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
604 end
= buf
+ hdr_length
;
606 this_inf
->offset
= last_fde
- ehbuf
;
607 this_inf
->size
= 4 + hdr_length
;
608 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
612 /* A zero-length CIE should only be found at the end of
614 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
615 ENSURE_NO_RELOCS (buf
);
620 REQUIRE (skip_bytes (&buf
, end
, 4));
621 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
625 unsigned int initial_insn_length
;
630 /* Point CIE to one of the section-local cie structures. */
631 cie
= local_cies
+ cie_count
++;
633 cie
->cie_inf
= this_inf
;
634 cie
->length
= hdr_length
;
635 cie
->output_sec
= sec
->output_section
;
637 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
639 /* Cannot handle unknown versions. */
640 REQUIRE (cie
->version
== 1
642 || cie
->version
== 4);
643 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
645 strcpy (cie
->augmentation
, (char *) buf
);
646 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
647 ENSURE_NO_RELOCS (buf
);
648 if (buf
[0] == 'e' && buf
[1] == 'h')
650 /* GCC < 3.0 .eh_frame CIE */
651 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
652 is private to each CIE, so we don't need it for anything.
654 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
657 if (cie
->version
>= 4)
659 REQUIRE (buf
+ 1 < end
);
660 REQUIRE (buf
[0] == ptr_size
);
661 REQUIRE (buf
[1] == 0);
664 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
665 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
666 if (cie
->version
== 1)
669 cie
->ra_column
= *buf
++;
672 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
673 ENSURE_NO_RELOCS (buf
);
674 cie
->lsda_encoding
= DW_EH_PE_omit
;
675 cie
->fde_encoding
= DW_EH_PE_omit
;
676 cie
->per_encoding
= DW_EH_PE_omit
;
677 aug
= cie
->augmentation
;
678 if (aug
[0] != 'e' || aug
[1] != 'h')
683 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
684 ENSURE_NO_RELOCS (buf
);
691 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
692 ENSURE_NO_RELOCS (buf
);
693 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
696 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
697 ENSURE_NO_RELOCS (buf
);
698 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
706 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
707 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
710 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
712 length
= -(buf
- ehbuf
) & (per_width
- 1);
713 REQUIRE (skip_bytes (&buf
, end
, length
));
715 this_inf
->u
.cie
.personality_offset
= buf
- start
;
716 ENSURE_NO_RELOCS (buf
);
717 /* Ensure we have a reloc here. */
718 REQUIRE (GET_RELOC (buf
));
719 cie
->personality
.reloc_index
720 = cookie
->rel
- cookie
->rels
;
721 /* Cope with MIPS-style composite relocations. */
724 while (GET_RELOC (buf
) != NULL
);
725 REQUIRE (skip_bytes (&buf
, end
, per_width
));
729 /* Unrecognized augmentation. Better bail out. */
734 /* For shared libraries, try to get rid of as many RELATIVE relocs
737 && (get_elf_backend_data (abfd
)
738 ->elf_backend_can_make_relative_eh_frame
741 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
742 this_inf
->make_relative
= 1;
743 /* If the CIE doesn't already have an 'R' entry, it's fairly
744 easy to add one, provided that there's no aligned data
745 after the augmentation string. */
746 else if (cie
->fde_encoding
== DW_EH_PE_omit
747 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
749 if (*cie
->augmentation
== 0)
750 this_inf
->add_augmentation_size
= 1;
751 this_inf
->u
.cie
.add_fde_encoding
= 1;
752 this_inf
->make_relative
= 1;
755 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
756 cie
->can_make_lsda_relative
= 1;
759 /* If FDE encoding was not specified, it defaults to
761 if (cie
->fde_encoding
== DW_EH_PE_omit
)
762 cie
->fde_encoding
= DW_EH_PE_absptr
;
764 initial_insn_length
= end
- buf
;
765 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
767 cie
->initial_insn_length
= initial_insn_length
;
768 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
771 buf
+= initial_insn_length
;
772 ENSURE_NO_RELOCS (buf
);
774 if (hdr_info
->merge_cies
)
775 this_inf
->u
.cie
.u
.full_cie
= cie
;
776 this_inf
->u
.cie
.per_encoding_relative
777 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
781 /* Find the corresponding CIE. */
782 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
783 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
784 if (cie_offset
== cie
->cie_inf
->offset
)
787 /* Ensure this FDE references one of the CIEs in this input
789 REQUIRE (cie
!= local_cies
+ cie_count
);
790 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
791 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
792 this_inf
->add_augmentation_size
793 = cie
->cie_inf
->add_augmentation_size
;
795 ENSURE_NO_RELOCS (buf
);
796 if ((sec
->flags
& SEC_LINKER_CREATED
) == 0 || cookie
->rels
!= NULL
)
800 REQUIRE (GET_RELOC (buf
));
802 /* Chain together the FDEs for each section. */
803 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
804 /* RSEC will be NULL if FDE was cleared out as it was belonging to
805 a discarded SHT_GROUP. */
808 REQUIRE (rsec
->owner
== abfd
);
809 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
810 elf_fde_list (rsec
) = this_inf
;
814 /* Skip the initial location and address range. */
816 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
817 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
819 /* Skip the augmentation size, if present. */
820 if (cie
->augmentation
[0] == 'z')
821 REQUIRE (read_uleb128 (&buf
, end
, &length
));
825 /* Of the supported augmentation characters above, only 'L'
826 adds augmentation data to the FDE. This code would need to
827 be adjusted if any future augmentations do the same thing. */
828 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
831 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
832 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
833 this_inf
->lsda_offset
= buf
- start
;
834 /* If there's no 'z' augmentation, we don't know where the
835 CFA insns begin. Assume no padding. */
836 if (cie
->augmentation
[0] != 'z')
840 /* Skip over the augmentation data. */
841 REQUIRE (skip_bytes (&buf
, end
, length
));
844 buf
= last_fde
+ 4 + hdr_length
;
846 /* For NULL RSEC (cleared FDE belonging to a discarded section)
847 the relocations are commonly cleared. We do not sanity check if
848 all these relocations are cleared as (1) relocations to
849 .gcc_except_table will remain uncleared (they will get dropped
850 with the drop of this unused FDE) and (2) BFD already safely drops
851 relocations of any type to .eh_frame by
852 elf_section_ignore_discarded_relocs.
853 TODO: The .gcc_except_table entries should be also filtered as
854 .eh_frame entries; or GCC could rather use COMDAT for them. */
858 /* Try to interpret the CFA instructions and find the first
859 padding nop. Shrink this_inf's size so that it doesn't
860 include the padding. */
861 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
863 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
864 /* If we don't understand the CFA instructions, we can't know
865 what needs to be adjusted there. */
866 if (insns_end
== NULL
867 /* For the time being we don't support DW_CFA_set_loc in
869 || (set_loc_count
&& this_inf
->cie
))
871 this_inf
->size
-= end
- insns_end
;
872 if (insns_end
!= end
&& this_inf
->cie
)
874 cie
->initial_insn_length
-= end
- insns_end
;
875 cie
->length
-= end
- insns_end
;
878 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
879 || this_inf
->make_relative
))
884 this_inf
->set_loc
= (unsigned int *)
885 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
886 REQUIRE (this_inf
->set_loc
);
887 this_inf
->set_loc
[0] = set_loc_count
;
892 if (*p
== DW_CFA_set_loc
)
893 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
894 REQUIRE (skip_cfa_op (&p
, end
, length
));
898 this_inf
->removed
= 1;
899 this_inf
->fde_encoding
= cie
->fde_encoding
;
900 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
903 BFD_ASSERT (sec_info
->count
== num_entries
);
904 BFD_ASSERT (cie_count
== num_cies
);
906 elf_section_data (sec
)->sec_info
= sec_info
;
907 sec
->sec_info_type
= SEC_INFO_TYPE_EH_FRAME
;
908 if (hdr_info
->merge_cies
)
910 sec_info
->cies
= local_cies
;
916 (*info
->callbacks
->einfo
)
917 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
919 hdr_info
->table
= FALSE
;
930 /* Finish a pass over all .eh_frame sections. */
933 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
935 struct eh_frame_hdr_info
*hdr_info
;
937 hdr_info
= &elf_hash_table (info
)->eh_info
;
938 hdr_info
->parsed_eh_frames
= TRUE
;
941 /* Mark all relocations against CIE or FDE ENT, which occurs in
942 .eh_frame section SEC. COOKIE describes the relocations in SEC;
943 its "rel" field can be changed freely. */
946 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
947 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
948 struct elf_reloc_cookie
*cookie
)
950 /* FIXME: octets_per_byte. */
951 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
952 cookie
->rel
< cookie
->relend
953 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
955 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
961 /* Mark all the relocations against FDEs that relate to code in input
962 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
963 relocations are described by COOKIE. */
966 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
967 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
968 struct elf_reloc_cookie
*cookie
)
970 struct eh_cie_fde
*fde
, *cie
;
972 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
974 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
977 /* At this stage, all cie_inf fields point to local CIEs, so we
978 can use the same cookie to refer to them. */
979 cie
= fde
->u
.fde
.cie_inf
;
980 if (!cie
->u
.cie
.gc_mark
)
982 cie
->u
.cie
.gc_mark
= 1;
983 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
990 /* Input section SEC of ABFD is an .eh_frame section that contains the
991 CIE described by CIE_INF. Return a version of CIE_INF that is going
992 to be kept in the output, adding CIE_INF to the output if necessary.
994 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
995 relocations in REL. */
997 static struct eh_cie_fde
*
998 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
999 struct eh_frame_hdr_info
*hdr_info
,
1000 struct elf_reloc_cookie
*cookie
,
1001 struct eh_cie_fde
*cie_inf
)
1003 unsigned long r_symndx
;
1004 struct cie
*cie
, *new_cie
;
1005 Elf_Internal_Rela
*rel
;
1008 /* Use CIE_INF if we have already decided to keep it. */
1009 if (!cie_inf
->removed
)
1012 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1013 if (cie_inf
->u
.cie
.merged
)
1014 return cie_inf
->u
.cie
.u
.merged_with
;
1016 cie
= cie_inf
->u
.cie
.u
.full_cie
;
1018 /* Assume we will need to keep CIE_INF. */
1019 cie_inf
->removed
= 0;
1020 cie_inf
->u
.cie
.u
.sec
= sec
;
1022 /* If we are not merging CIEs, use CIE_INF. */
1026 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1028 bfd_boolean per_binds_local
;
1030 /* Work out the address of personality routine, either as an absolute
1031 value or as a symbol. */
1032 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
1033 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1035 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1036 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1039 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1040 if (r_symndx
>= cookie
->locsymcount
1041 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1043 struct elf_link_hash_entry
*h
;
1045 r_symndx
-= cookie
->extsymoff
;
1046 h
= cookie
->sym_hashes
[r_symndx
];
1048 while (h
->root
.type
== bfd_link_hash_indirect
1049 || h
->root
.type
== bfd_link_hash_warning
)
1050 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1052 cie
->personality
.h
= h
;
1053 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1057 Elf_Internal_Sym
*sym
;
1060 sym
= &cookie
->locsyms
[r_symndx
];
1061 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1062 if (sym_sec
== NULL
)
1065 if (sym_sec
->kept_section
!= NULL
)
1066 sym_sec
= sym_sec
->kept_section
;
1067 if (sym_sec
->output_section
== NULL
)
1070 cie
->local_personality
= 1;
1071 cie
->personality
.val
= (sym
->st_value
1072 + sym_sec
->output_offset
1073 + sym_sec
->output_section
->vma
);
1074 per_binds_local
= TRUE
;
1079 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1080 && (get_elf_backend_data (abfd
)
1081 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1083 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1084 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1088 /* See if we can merge this CIE with an earlier one. */
1089 cie
->output_sec
= sec
->output_section
;
1090 cie_compute_hash (cie
);
1091 if (hdr_info
->cies
== NULL
)
1093 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1094 if (hdr_info
->cies
== NULL
)
1097 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
, cie
->hash
, INSERT
);
1101 new_cie
= (struct cie
*) *loc
;
1102 if (new_cie
== NULL
)
1104 /* Keep CIE_INF and record it in the hash table. */
1105 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1106 if (new_cie
== NULL
)
1109 memcpy (new_cie
, cie
, sizeof (struct cie
));
1114 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1115 cie_inf
->removed
= 1;
1116 cie_inf
->u
.cie
.merged
= 1;
1117 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1118 if (cie_inf
->u
.cie
.make_lsda_relative
)
1119 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1121 return new_cie
->cie_inf
;
1124 /* This function is called for each input file before the .eh_frame
1125 section is relocated. It discards duplicate CIEs and FDEs for discarded
1126 functions. The function returns TRUE iff any entries have been
1130 _bfd_elf_discard_section_eh_frame
1131 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1132 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1133 struct elf_reloc_cookie
*cookie
)
1135 struct eh_cie_fde
*ent
;
1136 struct eh_frame_sec_info
*sec_info
;
1137 struct eh_frame_hdr_info
*hdr_info
;
1138 unsigned int ptr_size
, offset
;
1140 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1143 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1144 if (sec_info
== NULL
)
1147 ptr_size
= (get_elf_backend_data (sec
->owner
)
1148 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1150 hdr_info
= &elf_hash_table (info
)->eh_info
;
1151 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1153 /* There should only be one zero terminator, on the last input
1154 file supplying .eh_frame (crtend.o). Remove any others. */
1155 ent
->removed
= sec
->map_head
.s
!= NULL
;
1159 if ((sec
->flags
& SEC_LINKER_CREATED
) != 0 && cookie
->rels
== NULL
)
1162 = get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1164 = read_value (abfd
, sec
->contents
+ ent
->offset
+ 8 + width
,
1165 width
, get_DW_EH_PE_signed (ent
->fde_encoding
));
1170 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1171 /* FIXME: octets_per_byte. */
1172 BFD_ASSERT (cookie
->rel
< cookie
->relend
1173 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1174 keep
= !(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
);
1179 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1180 && ent
->make_relative
== 0)
1181 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1183 /* If a shared library uses absolute pointers
1184 which we cannot turn into PC relative,
1185 don't create the binary search table,
1186 since it is affected by runtime relocations. */
1187 hdr_info
->table
= FALSE
;
1188 (*info
->callbacks
->einfo
)
1189 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1190 " table being created.\n"), abfd
, sec
);
1193 hdr_info
->fde_count
++;
1194 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1195 cookie
, ent
->u
.fde
.cie_inf
);
1201 free (sec_info
->cies
);
1202 sec_info
->cies
= NULL
;
1206 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1209 ent
->new_offset
= offset
;
1210 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1213 sec
->rawsize
= sec
->size
;
1215 return offset
!= sec
->rawsize
;
1218 /* This function is called for .eh_frame_hdr section after
1219 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1220 input sections. It finalizes the size of .eh_frame_hdr section. */
1223 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1225 struct elf_link_hash_table
*htab
;
1226 struct eh_frame_hdr_info
*hdr_info
;
1229 htab
= elf_hash_table (info
);
1230 hdr_info
= &htab
->eh_info
;
1232 if (hdr_info
->cies
!= NULL
)
1234 htab_delete (hdr_info
->cies
);
1235 hdr_info
->cies
= NULL
;
1238 sec
= hdr_info
->hdr_sec
;
1242 sec
->size
= EH_FRAME_HDR_SIZE
;
1243 if (hdr_info
->table
)
1244 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1246 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1250 /* This function is called from size_dynamic_sections.
1251 It needs to decide whether .eh_frame_hdr should be output or not,
1252 because when the dynamic symbol table has been sized it is too late
1253 to strip sections. */
1256 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1260 struct elf_link_hash_table
*htab
;
1261 struct eh_frame_hdr_info
*hdr_info
;
1263 htab
= elf_hash_table (info
);
1264 hdr_info
= &htab
->eh_info
;
1265 if (hdr_info
->hdr_sec
== NULL
)
1268 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1270 hdr_info
->hdr_sec
= NULL
;
1275 if (info
->eh_frame_hdr
)
1276 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1278 /* Count only sections which have at least a single CIE or FDE.
1279 There cannot be any CIE or FDE <= 8 bytes. */
1280 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1283 || bfd_is_abs_section (o
->output_section
)))
1284 o
= bfd_get_next_section_by_name (o
);
1291 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1292 hdr_info
->hdr_sec
= NULL
;
1296 hdr_info
->table
= TRUE
;
1300 /* Adjust an address in the .eh_frame section. Given OFFSET within
1301 SEC, this returns the new offset in the adjusted .eh_frame section,
1302 or -1 if the address refers to a CIE/FDE which has been removed
1303 or to offset with dynamic relocation which is no longer needed. */
1306 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1307 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1311 struct eh_frame_sec_info
*sec_info
;
1312 unsigned int lo
, hi
, mid
;
1314 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1316 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1318 if (offset
>= sec
->rawsize
)
1319 return offset
- sec
->rawsize
+ sec
->size
;
1322 hi
= sec_info
->count
;
1326 mid
= (lo
+ hi
) / 2;
1327 if (offset
< sec_info
->entry
[mid
].offset
)
1330 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1336 BFD_ASSERT (lo
< hi
);
1338 /* FDE or CIE was removed. */
1339 if (sec_info
->entry
[mid
].removed
)
1340 return (bfd_vma
) -1;
1342 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1343 no need for run-time relocation against the personality field. */
1344 if (sec_info
->entry
[mid
].cie
1345 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1346 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1347 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1348 return (bfd_vma
) -2;
1350 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1351 relocation against FDE's initial_location field. */
1352 if (!sec_info
->entry
[mid
].cie
1353 && sec_info
->entry
[mid
].make_relative
1354 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1355 return (bfd_vma
) -2;
1357 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1358 for run-time relocation against LSDA field. */
1359 if (!sec_info
->entry
[mid
].cie
1360 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1361 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1362 + sec_info
->entry
[mid
].lsda_offset
))
1363 return (bfd_vma
) -2;
1365 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1366 relocation against DW_CFA_set_loc's arguments. */
1367 if (sec_info
->entry
[mid
].set_loc
1368 && sec_info
->entry
[mid
].make_relative
1369 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1370 + sec_info
->entry
[mid
].set_loc
[1]))
1374 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1375 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1376 + sec_info
->entry
[mid
].set_loc
[cnt
])
1377 return (bfd_vma
) -2;
1380 /* Any new augmentation bytes go before the first relocation. */
1381 return (offset
+ sec_info
->entry
[mid
].new_offset
1382 - sec_info
->entry
[mid
].offset
1383 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1384 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1387 /* Write out .eh_frame section. This is called with the relocated
1391 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1392 struct bfd_link_info
*info
,
1396 struct eh_frame_sec_info
*sec_info
;
1397 struct elf_link_hash_table
*htab
;
1398 struct eh_frame_hdr_info
*hdr_info
;
1399 unsigned int ptr_size
;
1400 struct eh_cie_fde
*ent
;
1402 if (sec
->sec_info_type
!= SEC_INFO_TYPE_EH_FRAME
)
1403 /* FIXME: octets_per_byte. */
1404 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1405 sec
->output_offset
, sec
->size
);
1407 ptr_size
= (get_elf_backend_data (abfd
)
1408 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1409 BFD_ASSERT (ptr_size
!= 0);
1411 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1412 htab
= elf_hash_table (info
);
1413 hdr_info
= &htab
->eh_info
;
1415 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1416 hdr_info
->array
= (struct eh_frame_array_ent
*)
1417 bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1418 if (hdr_info
->array
== NULL
)
1421 /* The new offsets can be bigger or smaller than the original offsets.
1422 We therefore need to make two passes over the section: one backward
1423 pass to move entries up and one forward pass to move entries down.
1424 The two passes won't interfere with each other because entries are
1426 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1427 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1428 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1430 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1431 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1432 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1434 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1436 unsigned char *buf
, *end
;
1437 unsigned int new_size
;
1444 /* Any terminating FDE must be at the end of the section. */
1445 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1449 buf
= contents
+ ent
->new_offset
;
1450 end
= buf
+ ent
->size
;
1451 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1453 /* Update the size. It may be shrinked. */
1454 bfd_put_32 (abfd
, new_size
- 4, buf
);
1456 /* Filling the extra bytes with DW_CFA_nops. */
1457 if (new_size
!= ent
->size
)
1458 memset (end
, 0, new_size
- ent
->size
);
1463 if (ent
->make_relative
1464 || ent
->u
.cie
.make_lsda_relative
1465 || ent
->u
.cie
.per_encoding_relative
)
1468 unsigned int action
, extra_string
, extra_data
;
1469 unsigned int per_width
, per_encoding
;
1471 /* Need to find 'R' or 'L' augmentation's argument and modify
1472 DW_EH_PE_* value. */
1473 action
= ((ent
->make_relative
? 1 : 0)
1474 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1475 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1476 extra_string
= extra_augmentation_string_bytes (ent
);
1477 extra_data
= extra_augmentation_data_bytes (ent
);
1479 /* Skip length, id and version. */
1482 buf
+= strlen (aug
) + 1;
1483 skip_leb128 (&buf
, end
);
1484 skip_leb128 (&buf
, end
);
1485 skip_leb128 (&buf
, end
);
1488 /* The uleb128 will always be a single byte for the kind
1489 of augmentation strings that we're prepared to handle. */
1490 *buf
++ += extra_data
;
1494 /* Make room for the new augmentation string and data bytes. */
1495 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1496 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1497 buf
+= extra_string
;
1498 end
+= extra_string
+ extra_data
;
1500 if (ent
->add_augmentation_size
)
1503 *buf
++ = extra_data
- 1;
1505 if (ent
->u
.cie
.add_fde_encoding
)
1507 BFD_ASSERT (action
& 1);
1509 *buf
++ = make_pc_relative (DW_EH_PE_absptr
, ptr_size
);
1519 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1520 *buf
= make_pc_relative (*buf
, ptr_size
);
1526 if (ent
->u
.cie
.make_per_encoding_relative
)
1527 *buf
= make_pc_relative (*buf
, ptr_size
);
1528 per_encoding
= *buf
++;
1529 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1530 BFD_ASSERT (per_width
!= 0);
1531 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1532 == ent
->u
.cie
.per_encoding_relative
);
1533 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
1535 + ((buf
- contents
+ per_width
- 1)
1536 & ~((bfd_size_type
) per_width
- 1)));
1541 val
= read_value (abfd
, buf
, per_width
,
1542 get_DW_EH_PE_signed (per_encoding
));
1543 if (ent
->u
.cie
.make_per_encoding_relative
)
1544 val
-= (sec
->output_section
->vma
1545 + sec
->output_offset
1546 + (buf
- contents
));
1549 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1550 val
-= extra_string
+ extra_data
;
1552 write_value (abfd
, buf
, val
, per_width
);
1560 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1561 *buf
= make_pc_relative (*buf
, ptr_size
);
1576 bfd_vma value
, address
;
1579 struct eh_cie_fde
*cie
;
1582 cie
= ent
->u
.fde
.cie_inf
;
1584 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1585 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1586 bfd_put_32 (abfd
, value
, buf
);
1588 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1589 value
= read_value (abfd
, buf
, width
,
1590 get_DW_EH_PE_signed (ent
->fde_encoding
));
1594 switch (ent
->fde_encoding
& 0x70)
1596 case DW_EH_PE_textrel
:
1597 BFD_ASSERT (hdr_info
== NULL
);
1599 case DW_EH_PE_datarel
:
1601 switch (abfd
->arch_info
->arch
)
1604 BFD_ASSERT (elf_gp (abfd
) != 0);
1605 address
+= elf_gp (abfd
);
1608 (*info
->callbacks
->einfo
)
1609 (_("%P: DW_EH_PE_datarel unspecified"
1610 " for this architecture.\n"));
1614 BFD_ASSERT (htab
->hgot
!= NULL
1615 && ((htab
->hgot
->root
.type
1616 == bfd_link_hash_defined
)
1617 || (htab
->hgot
->root
.type
1618 == bfd_link_hash_defweak
)));
1620 += (htab
->hgot
->root
.u
.def
.value
1621 + htab
->hgot
->root
.u
.def
.section
->output_offset
1622 + (htab
->hgot
->root
.u
.def
.section
->output_section
1628 case DW_EH_PE_pcrel
:
1629 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1630 address
+= (sec
->output_section
->vma
1631 + sec
->output_offset
1635 if (ent
->make_relative
)
1636 value
-= (sec
->output_section
->vma
1637 + sec
->output_offset
1638 + ent
->new_offset
+ 8);
1639 write_value (abfd
, buf
, value
, width
);
1646 /* The address calculation may overflow, giving us a
1647 value greater than 4G on a 32-bit target when
1648 dwarf_vma is 64-bit. */
1649 if (sizeof (address
) > 4 && ptr_size
== 4)
1650 address
&= 0xffffffff;
1651 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1652 hdr_info
->array
[hdr_info
->array_count
++].fde
1653 = (sec
->output_section
->vma
1654 + sec
->output_offset
1658 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
1659 || cie
->u
.cie
.make_lsda_relative
)
1661 buf
+= ent
->lsda_offset
;
1662 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1663 value
= read_value (abfd
, buf
, width
,
1664 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1667 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1668 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1669 else if (cie
->u
.cie
.make_lsda_relative
)
1670 value
-= (sec
->output_section
->vma
1671 + sec
->output_offset
1672 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1673 write_value (abfd
, buf
, value
, width
);
1676 else if (ent
->add_augmentation_size
)
1678 /* Skip the PC and length and insert a zero byte for the
1679 augmentation size. */
1681 memmove (buf
+ 1, buf
, end
- buf
);
1687 /* Adjust DW_CFA_set_loc. */
1691 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1692 new_offset
= ent
->new_offset
+ 8
1693 + extra_augmentation_string_bytes (ent
)
1694 + extra_augmentation_data_bytes (ent
);
1696 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1698 buf
= start
+ ent
->set_loc
[cnt
];
1700 value
= read_value (abfd
, buf
, width
,
1701 get_DW_EH_PE_signed (ent
->fde_encoding
));
1705 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
1706 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
1707 if (ent
->make_relative
)
1708 value
-= (sec
->output_section
->vma
1709 + sec
->output_offset
1710 + new_offset
+ ent
->set_loc
[cnt
]);
1711 write_value (abfd
, buf
, value
, width
);
1717 /* We don't align the section to its section alignment since the
1718 runtime library only expects all CIE/FDE records aligned at
1719 the pointer size. _bfd_elf_discard_section_eh_frame should
1720 have padded CIE/FDE records to multiple of pointer size with
1721 size_of_output_cie_fde. */
1722 if ((sec
->size
% ptr_size
) != 0)
1725 /* FIXME: octets_per_byte. */
1726 return bfd_set_section_contents (abfd
, sec
->output_section
,
1727 contents
, (file_ptr
) sec
->output_offset
,
1731 /* Helper function used to sort .eh_frame_hdr search table by increasing
1732 VMA of FDE initial location. */
1735 vma_compare (const void *a
, const void *b
)
1737 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
1738 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
1739 if (p
->initial_loc
> q
->initial_loc
)
1741 if (p
->initial_loc
< q
->initial_loc
)
1746 /* Write out .eh_frame_hdr section. This must be called after
1747 _bfd_elf_write_section_eh_frame has been called on all input
1749 .eh_frame_hdr format:
1750 ubyte version (currently 1)
1751 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1753 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1754 number (or DW_EH_PE_omit if there is no
1755 binary search table computed))
1756 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1757 or DW_EH_PE_omit if not present.
1758 DW_EH_PE_datarel is using address of
1759 .eh_frame_hdr section start as base)
1760 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1761 optionally followed by:
1762 [encoded] fde_count (total number of FDEs in .eh_frame section)
1763 fde_count x [encoded] initial_loc, fde
1764 (array of encoded pairs containing
1765 FDE initial_location field and FDE address,
1766 sorted by increasing initial_loc). */
1769 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1771 struct elf_link_hash_table
*htab
;
1772 struct eh_frame_hdr_info
*hdr_info
;
1775 asection
*eh_frame_sec
;
1778 bfd_vma encoded_eh_frame
;
1780 htab
= elf_hash_table (info
);
1781 hdr_info
= &htab
->eh_info
;
1782 sec
= hdr_info
->hdr_sec
;
1786 size
= EH_FRAME_HDR_SIZE
;
1787 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1788 size
+= 4 + hdr_info
->fde_count
* 8;
1789 contents
= (bfd_byte
*) bfd_malloc (size
);
1790 if (contents
== NULL
)
1793 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1794 if (eh_frame_sec
== NULL
)
1800 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1801 contents
[0] = 1; /* Version. */
1802 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1803 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1804 &encoded_eh_frame
); /* .eh_frame offset. */
1806 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1808 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1809 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1813 contents
[2] = DW_EH_PE_omit
;
1814 contents
[3] = DW_EH_PE_omit
;
1816 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1818 if (contents
[2] != DW_EH_PE_omit
)
1822 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1823 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1825 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1828 hdr_info
->array
[i
].initial_loc
1829 - sec
->output_section
->vma
,
1830 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1832 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1833 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1837 /* FIXME: octets_per_byte. */
1838 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1839 contents
, (file_ptr
) sec
->output_offset
,
1845 /* Return the width of FDE addresses. This is the default implementation. */
1848 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1850 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1853 /* Decide whether we can use a PC-relative encoding within the given
1854 EH frame section. This is the default implementation. */
1857 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1858 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1859 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1864 /* Select an encoding for the given address. Preference is given to
1865 PC-relative addressing modes. */
1868 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1869 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1870 asection
*osec
, bfd_vma offset
,
1871 asection
*loc_sec
, bfd_vma loc_offset
,
1874 *encoded
= osec
->vma
+ offset
-
1875 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1876 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;