1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
3 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 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
427 .eh_frame section. */
430 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
432 struct eh_frame_hdr_info
*hdr_info
;
434 hdr_info
= &elf_hash_table (info
)->eh_info
;
435 hdr_info
->merge_cies
= !info
->relocatable
;
438 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
439 information in the section's sec_info field on success. COOKIE
440 describes the relocations in SEC. */
443 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
444 asection
*sec
, struct elf_reloc_cookie
*cookie
)
446 #define REQUIRE(COND) \
449 goto free_no_table; \
452 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
454 struct eh_cie_fde
*this_inf
;
455 unsigned int hdr_length
, hdr_id
;
456 unsigned int cie_count
;
457 struct cie
*cie
, *local_cies
= NULL
;
458 struct elf_link_hash_table
*htab
;
459 struct eh_frame_hdr_info
*hdr_info
;
460 struct eh_frame_sec_info
*sec_info
= NULL
;
461 unsigned int ptr_size
;
462 unsigned int num_cies
;
463 unsigned int num_entries
;
464 elf_gc_mark_hook_fn gc_mark_hook
;
466 htab
= elf_hash_table (info
);
467 hdr_info
= &htab
->eh_info
;
468 if (hdr_info
->parsed_eh_frames
)
473 /* This file does not contain .eh_frame information. */
477 if (bfd_is_abs_section (sec
->output_section
))
479 /* At least one of the sections is being discarded from the
480 link, so we should just ignore them. */
484 /* Read the frame unwind information from abfd. */
486 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
489 && bfd_get_32 (abfd
, ehbuf
) == 0
490 && cookie
->rel
== cookie
->relend
)
492 /* Empty .eh_frame section. */
497 /* If .eh_frame section size doesn't fit into int, we cannot handle
498 it (it would need to use 64-bit .eh_frame format anyway). */
499 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
501 ptr_size
= (get_elf_backend_data (abfd
)
502 ->elf_backend_eh_frame_address_size (abfd
, sec
));
503 REQUIRE (ptr_size
!= 0);
505 /* Go through the section contents and work out how many FDEs and
508 end
= ehbuf
+ sec
->size
;
515 /* Read the length of the entry. */
516 REQUIRE (skip_bytes (&buf
, end
, 4));
517 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
519 /* 64-bit .eh_frame is not supported. */
520 REQUIRE (hdr_length
!= 0xffffffff);
524 REQUIRE (skip_bytes (&buf
, end
, 4));
525 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
529 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
532 sec_info
= (struct eh_frame_sec_info
*)
533 bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
534 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
537 /* We need to have a "struct cie" for each CIE in this section. */
538 local_cies
= (struct cie
*) bfd_zmalloc (num_cies
* sizeof (*local_cies
));
539 REQUIRE (local_cies
);
541 /* FIXME: octets_per_byte. */
542 #define ENSURE_NO_RELOCS(buf) \
543 REQUIRE (!(cookie->rel < cookie->relend \
544 && (cookie->rel->r_offset \
545 < (bfd_size_type) ((buf) - ehbuf)) \
546 && cookie->rel->r_info != 0))
548 /* FIXME: octets_per_byte. */
549 #define SKIP_RELOCS(buf) \
550 while (cookie->rel < cookie->relend \
551 && (cookie->rel->r_offset \
552 < (bfd_size_type) ((buf) - ehbuf))) \
555 /* FIXME: octets_per_byte. */
556 #define GET_RELOC(buf) \
557 ((cookie->rel < cookie->relend \
558 && (cookie->rel->r_offset \
559 == (bfd_size_type) ((buf) - ehbuf))) \
560 ? cookie->rel : NULL)
564 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
565 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
568 bfd_byte
*start
, *insns
, *insns_end
;
569 bfd_size_type length
;
570 unsigned int set_loc_count
;
572 this_inf
= sec_info
->entry
+ sec_info
->count
;
575 /* Read the length of the entry. */
576 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
577 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
579 /* The CIE/FDE must be fully contained in this input section. */
580 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
581 end
= buf
+ hdr_length
;
583 this_inf
->offset
= last_fde
- ehbuf
;
584 this_inf
->size
= 4 + hdr_length
;
585 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
589 /* A zero-length CIE should only be found at the end of
591 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
592 ENSURE_NO_RELOCS (buf
);
597 REQUIRE (skip_bytes (&buf
, end
, 4));
598 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
602 unsigned int initial_insn_length
;
607 /* Point CIE to one of the section-local cie structures. */
608 cie
= local_cies
+ cie_count
++;
610 cie
->cie_inf
= this_inf
;
611 cie
->length
= hdr_length
;
612 cie
->output_sec
= sec
->output_section
;
614 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
616 /* Cannot handle unknown versions. */
617 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
618 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
620 strcpy (cie
->augmentation
, (char *) buf
);
621 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
622 ENSURE_NO_RELOCS (buf
);
623 if (buf
[0] == 'e' && buf
[1] == 'h')
625 /* GCC < 3.0 .eh_frame CIE */
626 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
627 is private to each CIE, so we don't need it for anything.
629 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
632 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
633 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
634 if (cie
->version
== 1)
637 cie
->ra_column
= *buf
++;
640 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
641 ENSURE_NO_RELOCS (buf
);
642 cie
->lsda_encoding
= DW_EH_PE_omit
;
643 cie
->fde_encoding
= DW_EH_PE_omit
;
644 cie
->per_encoding
= DW_EH_PE_omit
;
645 aug
= cie
->augmentation
;
646 if (aug
[0] != 'e' || aug
[1] != 'h')
651 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
652 ENSURE_NO_RELOCS (buf
);
659 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
660 ENSURE_NO_RELOCS (buf
);
661 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
664 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
665 ENSURE_NO_RELOCS (buf
);
666 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
674 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
675 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
678 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_aligned
)
680 length
= -(buf
- ehbuf
) & (per_width
- 1);
681 REQUIRE (skip_bytes (&buf
, end
, length
));
683 this_inf
->u
.cie
.personality_offset
= buf
- start
;
684 ENSURE_NO_RELOCS (buf
);
685 /* Ensure we have a reloc here. */
686 REQUIRE (GET_RELOC (buf
));
687 cie
->personality
.reloc_index
688 = cookie
->rel
- cookie
->rels
;
689 /* Cope with MIPS-style composite relocations. */
692 while (GET_RELOC (buf
) != NULL
);
693 REQUIRE (skip_bytes (&buf
, end
, per_width
));
697 /* Unrecognized augmentation. Better bail out. */
702 /* For shared libraries, try to get rid of as many RELATIVE relocs
705 && (get_elf_backend_data (abfd
)
706 ->elf_backend_can_make_relative_eh_frame
709 if ((cie
->fde_encoding
& 0x70) == DW_EH_PE_absptr
)
710 this_inf
->make_relative
= 1;
711 /* If the CIE doesn't already have an 'R' entry, it's fairly
712 easy to add one, provided that there's no aligned data
713 after the augmentation string. */
714 else if (cie
->fde_encoding
== DW_EH_PE_omit
715 && (cie
->per_encoding
& 0x70) != DW_EH_PE_aligned
)
717 if (*cie
->augmentation
== 0)
718 this_inf
->add_augmentation_size
= 1;
719 this_inf
->u
.cie
.add_fde_encoding
= 1;
720 this_inf
->make_relative
= 1;
723 if ((cie
->lsda_encoding
& 0x70) == DW_EH_PE_absptr
)
724 cie
->can_make_lsda_relative
= 1;
727 /* If FDE encoding was not specified, it defaults to
729 if (cie
->fde_encoding
== DW_EH_PE_omit
)
730 cie
->fde_encoding
= DW_EH_PE_absptr
;
732 initial_insn_length
= end
- buf
;
733 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
735 cie
->initial_insn_length
= initial_insn_length
;
736 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
739 buf
+= initial_insn_length
;
740 ENSURE_NO_RELOCS (buf
);
742 if (hdr_info
->merge_cies
)
743 this_inf
->u
.cie
.u
.full_cie
= cie
;
744 this_inf
->u
.cie
.per_encoding_relative
745 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
751 /* Find the corresponding CIE. */
752 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
753 for (cie
= local_cies
; cie
< local_cies
+ cie_count
; cie
++)
754 if (cie_offset
== cie
->cie_inf
->offset
)
757 /* Ensure this FDE references one of the CIEs in this input
759 REQUIRE (cie
!= local_cies
+ cie_count
);
760 this_inf
->u
.fde
.cie_inf
= cie
->cie_inf
;
761 this_inf
->make_relative
= cie
->cie_inf
->make_relative
;
762 this_inf
->add_augmentation_size
763 = cie
->cie_inf
->add_augmentation_size
;
765 ENSURE_NO_RELOCS (buf
);
766 REQUIRE (GET_RELOC (buf
));
768 /* Chain together the FDEs for each section. */
769 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
770 /* RSEC will be NULL if FDE was cleared out as it was belonging to
771 a discarded SHT_GROUP. */
774 REQUIRE (rsec
->owner
== abfd
);
775 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
776 elf_fde_list (rsec
) = this_inf
;
779 /* Skip the initial location and address range. */
781 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
782 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
784 /* Skip the augmentation size, if present. */
785 if (cie
->augmentation
[0] == 'z')
786 REQUIRE (read_uleb128 (&buf
, end
, &length
));
790 /* Of the supported augmentation characters above, only 'L'
791 adds augmentation data to the FDE. This code would need to
792 be adjusted if any future augmentations do the same thing. */
793 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
796 if (cie
->can_make_lsda_relative
&& GET_RELOC (buf
))
797 cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
798 this_inf
->lsda_offset
= buf
- start
;
799 /* If there's no 'z' augmentation, we don't know where the
800 CFA insns begin. Assume no padding. */
801 if (cie
->augmentation
[0] != 'z')
805 /* Skip over the augmentation data. */
806 REQUIRE (skip_bytes (&buf
, end
, length
));
809 buf
= last_fde
+ 4 + hdr_length
;
811 /* For NULL RSEC (cleared FDE belonging to a discarded section)
812 the relocations are commonly cleared. We do not sanity check if
813 all these relocations are cleared as (1) relocations to
814 .gcc_except_table will remain uncleared (they will get dropped
815 with the drop of this unused FDE) and (2) BFD already safely drops
816 relocations of any type to .eh_frame by
817 elf_section_ignore_discarded_relocs.
818 TODO: The .gcc_except_table entries should be also filtered as
819 .eh_frame entries; or GCC could rather use COMDAT for them. */
823 /* Try to interpret the CFA instructions and find the first
824 padding nop. Shrink this_inf's size so that it doesn't
825 include the padding. */
826 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
828 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
829 /* If we don't understand the CFA instructions, we can't know
830 what needs to be adjusted there. */
831 if (insns_end
== NULL
832 /* For the time being we don't support DW_CFA_set_loc in
834 || (set_loc_count
&& this_inf
->cie
))
836 this_inf
->size
-= end
- insns_end
;
837 if (insns_end
!= end
&& this_inf
->cie
)
839 cie
->initial_insn_length
-= end
- insns_end
;
840 cie
->length
-= end
- insns_end
;
843 && ((cie
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
844 || this_inf
->make_relative
))
849 this_inf
->set_loc
= (unsigned int *)
850 bfd_malloc ((set_loc_count
+ 1) * sizeof (unsigned int));
851 REQUIRE (this_inf
->set_loc
);
852 this_inf
->set_loc
[0] = set_loc_count
;
857 if (*p
== DW_CFA_set_loc
)
858 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
859 REQUIRE (skip_cfa_op (&p
, end
, length
));
863 this_inf
->removed
= 1;
864 this_inf
->fde_encoding
= cie
->fde_encoding
;
865 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
868 BFD_ASSERT (sec_info
->count
== num_entries
);
869 BFD_ASSERT (cie_count
== num_cies
);
871 elf_section_data (sec
)->sec_info
= sec_info
;
872 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
873 if (hdr_info
->merge_cies
)
875 sec_info
->cies
= local_cies
;
881 (*info
->callbacks
->einfo
)
882 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
884 hdr_info
->table
= FALSE
;
895 /* Finish a pass over all .eh_frame sections. */
898 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
900 struct eh_frame_hdr_info
*hdr_info
;
902 hdr_info
= &elf_hash_table (info
)->eh_info
;
903 hdr_info
->parsed_eh_frames
= TRUE
;
906 /* Mark all relocations against CIE or FDE ENT, which occurs in
907 .eh_frame section SEC. COOKIE describes the relocations in SEC;
908 its "rel" field can be changed freely. */
911 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
912 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
913 struct elf_reloc_cookie
*cookie
)
915 /* FIXME: octets_per_byte. */
916 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
917 cookie
->rel
< cookie
->relend
918 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
920 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
926 /* Mark all the relocations against FDEs that relate to code in input
927 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
928 relocations are described by COOKIE. */
931 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
932 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
933 struct elf_reloc_cookie
*cookie
)
935 struct eh_cie_fde
*fde
, *cie
;
937 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
939 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
942 /* At this stage, all cie_inf fields point to local CIEs, so we
943 can use the same cookie to refer to them. */
944 cie
= fde
->u
.fde
.cie_inf
;
945 if (!cie
->u
.cie
.gc_mark
)
947 cie
->u
.cie
.gc_mark
= 1;
948 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
955 /* Input section SEC of ABFD is an .eh_frame section that contains the
956 CIE described by CIE_INF. Return a version of CIE_INF that is going
957 to be kept in the output, adding CIE_INF to the output if necessary.
959 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
960 relocations in REL. */
962 static struct eh_cie_fde
*
963 find_merged_cie (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
964 struct eh_frame_hdr_info
*hdr_info
,
965 struct elf_reloc_cookie
*cookie
,
966 struct eh_cie_fde
*cie_inf
)
968 unsigned long r_symndx
;
969 struct cie
*cie
, *new_cie
;
970 Elf_Internal_Rela
*rel
;
973 /* Use CIE_INF if we have already decided to keep it. */
974 if (!cie_inf
->removed
)
977 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
978 if (cie_inf
->u
.cie
.merged
)
979 return cie_inf
->u
.cie
.u
.merged_with
;
981 cie
= cie_inf
->u
.cie
.u
.full_cie
;
983 /* Assume we will need to keep CIE_INF. */
984 cie_inf
->removed
= 0;
985 cie_inf
->u
.cie
.u
.sec
= sec
;
987 /* If we are not merging CIEs, use CIE_INF. */
991 if (cie
->per_encoding
!= DW_EH_PE_omit
)
993 bfd_boolean per_binds_local
;
995 /* Work out the address of personality routine, either as an absolute
996 value or as a symbol. */
997 rel
= cookie
->rels
+ cie
->personality
.reloc_index
;
998 memset (&cie
->personality
, 0, sizeof (cie
->personality
));
1000 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
)
1001 r_symndx
= ELF64_R_SYM (rel
->r_info
);
1004 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1005 if (r_symndx
>= cookie
->locsymcount
1006 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
].st_info
) != STB_LOCAL
)
1008 struct elf_link_hash_entry
*h
;
1010 r_symndx
-= cookie
->extsymoff
;
1011 h
= cookie
->sym_hashes
[r_symndx
];
1013 while (h
->root
.type
== bfd_link_hash_indirect
1014 || h
->root
.type
== bfd_link_hash_warning
)
1015 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
1017 cie
->personality
.h
= h
;
1018 per_binds_local
= SYMBOL_REFERENCES_LOCAL (info
, h
);
1022 Elf_Internal_Sym
*sym
;
1025 sym
= &cookie
->locsyms
[r_symndx
];
1026 sym_sec
= bfd_section_from_elf_index (abfd
, sym
->st_shndx
);
1027 if (sym_sec
== NULL
)
1030 if (sym_sec
->kept_section
!= NULL
)
1031 sym_sec
= sym_sec
->kept_section
;
1032 if (sym_sec
->output_section
== NULL
)
1035 cie
->local_personality
= 1;
1036 cie
->personality
.val
= (sym
->st_value
1037 + sym_sec
->output_offset
1038 + sym_sec
->output_section
->vma
);
1039 per_binds_local
= TRUE
;
1044 && (cie
->per_encoding
& 0x70) == DW_EH_PE_absptr
1045 && (get_elf_backend_data (abfd
)
1046 ->elf_backend_can_make_relative_eh_frame (abfd
, info
, sec
)))
1048 cie_inf
->u
.cie
.make_per_encoding_relative
= 1;
1049 cie_inf
->u
.cie
.per_encoding_relative
= 1;
1053 /* See if we can merge this CIE with an earlier one. */
1054 cie
->output_sec
= sec
->output_section
;
1055 cie_compute_hash (cie
);
1056 if (hdr_info
->cies
== NULL
)
1058 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
1059 if (hdr_info
->cies
== NULL
)
1062 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
, cie
->hash
, INSERT
);
1066 new_cie
= (struct cie
*) *loc
;
1067 if (new_cie
== NULL
)
1069 /* Keep CIE_INF and record it in the hash table. */
1070 new_cie
= (struct cie
*) malloc (sizeof (struct cie
));
1071 if (new_cie
== NULL
)
1074 memcpy (new_cie
, cie
, sizeof (struct cie
));
1079 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1080 cie_inf
->removed
= 1;
1081 cie_inf
->u
.cie
.merged
= 1;
1082 cie_inf
->u
.cie
.u
.merged_with
= new_cie
->cie_inf
;
1083 if (cie_inf
->u
.cie
.make_lsda_relative
)
1084 new_cie
->cie_inf
->u
.cie
.make_lsda_relative
= 1;
1086 return new_cie
->cie_inf
;
1089 /* This function is called for each input file before the .eh_frame
1090 section is relocated. It discards duplicate CIEs and FDEs for discarded
1091 functions. The function returns TRUE iff any entries have been
1095 _bfd_elf_discard_section_eh_frame
1096 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1097 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1098 struct elf_reloc_cookie
*cookie
)
1100 struct eh_cie_fde
*ent
;
1101 struct eh_frame_sec_info
*sec_info
;
1102 struct eh_frame_hdr_info
*hdr_info
;
1103 unsigned int ptr_size
, offset
;
1105 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1106 if (sec_info
== NULL
)
1109 hdr_info
= &elf_hash_table (info
)->eh_info
;
1110 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1112 /* There should only be one zero terminator, on the last input
1113 file supplying .eh_frame (crtend.o). Remove any others. */
1114 ent
->removed
= sec
->map_head
.s
!= NULL
;
1117 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1118 /* FIXME: octets_per_byte. */
1119 BFD_ASSERT (cookie
->rel
< cookie
->relend
1120 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1121 if (!(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
))
1124 && (((ent
->fde_encoding
& 0x70) == DW_EH_PE_absptr
1125 && ent
->make_relative
== 0)
1126 || (ent
->fde_encoding
& 0x70) == DW_EH_PE_aligned
))
1128 /* If a shared library uses absolute pointers
1129 which we cannot turn into PC relative,
1130 don't create the binary search table,
1131 since it is affected by runtime relocations. */
1132 hdr_info
->table
= FALSE
;
1133 (*info
->callbacks
->einfo
)
1134 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1135 " table being created.\n"), abfd
, sec
);
1138 hdr_info
->fde_count
++;
1139 ent
->u
.fde
.cie_inf
= find_merged_cie (abfd
, info
, sec
, hdr_info
,
1140 cookie
, ent
->u
.fde
.cie_inf
);
1146 free (sec_info
->cies
);
1147 sec_info
->cies
= NULL
;
1150 ptr_size
= (get_elf_backend_data (sec
->owner
)
1151 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1153 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1156 ent
->new_offset
= offset
;
1157 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1160 sec
->rawsize
= sec
->size
;
1162 return offset
!= sec
->rawsize
;
1165 /* This function is called for .eh_frame_hdr section after
1166 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1167 input sections. It finalizes the size of .eh_frame_hdr section. */
1170 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1172 struct elf_link_hash_table
*htab
;
1173 struct eh_frame_hdr_info
*hdr_info
;
1176 htab
= elf_hash_table (info
);
1177 hdr_info
= &htab
->eh_info
;
1179 if (hdr_info
->cies
!= NULL
)
1181 htab_delete (hdr_info
->cies
);
1182 hdr_info
->cies
= NULL
;
1185 sec
= hdr_info
->hdr_sec
;
1189 sec
->size
= EH_FRAME_HDR_SIZE
;
1190 if (hdr_info
->table
)
1191 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1193 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1197 /* This function is called from size_dynamic_sections.
1198 It needs to decide whether .eh_frame_hdr should be output or not,
1199 because when the dynamic symbol table has been sized it is too late
1200 to strip sections. */
1203 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1207 struct elf_link_hash_table
*htab
;
1208 struct eh_frame_hdr_info
*hdr_info
;
1210 htab
= elf_hash_table (info
);
1211 hdr_info
= &htab
->eh_info
;
1212 if (hdr_info
->hdr_sec
== NULL
)
1215 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1217 hdr_info
->hdr_sec
= NULL
;
1222 if (info
->eh_frame_hdr
)
1223 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1225 /* Count only sections which have at least a single CIE or FDE.
1226 There cannot be any CIE or FDE <= 8 bytes. */
1227 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1228 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1234 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1235 hdr_info
->hdr_sec
= NULL
;
1239 hdr_info
->table
= TRUE
;
1243 /* Adjust an address in the .eh_frame section. Given OFFSET within
1244 SEC, this returns the new offset in the adjusted .eh_frame section,
1245 or -1 if the address refers to a CIE/FDE which has been removed
1246 or to offset with dynamic relocation which is no longer needed. */
1249 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1250 struct bfd_link_info
*info
,
1254 struct eh_frame_sec_info
*sec_info
;
1255 struct elf_link_hash_table
*htab
;
1256 struct eh_frame_hdr_info
*hdr_info
;
1257 unsigned int lo
, hi
, mid
;
1259 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1261 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1263 if (offset
>= sec
->rawsize
)
1264 return offset
- sec
->rawsize
+ sec
->size
;
1266 htab
= elf_hash_table (info
);
1267 hdr_info
= &htab
->eh_info
;
1270 hi
= sec_info
->count
;
1274 mid
= (lo
+ hi
) / 2;
1275 if (offset
< sec_info
->entry
[mid
].offset
)
1278 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1284 BFD_ASSERT (lo
< hi
);
1286 /* FDE or CIE was removed. */
1287 if (sec_info
->entry
[mid
].removed
)
1288 return (bfd_vma
) -1;
1290 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1291 no need for run-time relocation against the personality field. */
1292 if (sec_info
->entry
[mid
].cie
1293 && sec_info
->entry
[mid
].u
.cie
.make_per_encoding_relative
1294 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1295 + sec_info
->entry
[mid
].u
.cie
.personality_offset
))
1296 return (bfd_vma
) -2;
1298 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1299 relocation against FDE's initial_location field. */
1300 if (!sec_info
->entry
[mid
].cie
1301 && sec_info
->entry
[mid
].make_relative
1302 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1303 return (bfd_vma
) -2;
1305 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1306 for run-time relocation against LSDA field. */
1307 if (!sec_info
->entry
[mid
].cie
1308 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->u
.cie
.make_lsda_relative
1309 && offset
== (sec_info
->entry
[mid
].offset
+ 8
1310 + sec_info
->entry
[mid
].lsda_offset
))
1311 return (bfd_vma
) -2;
1313 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1314 relocation against DW_CFA_set_loc's arguments. */
1315 if (sec_info
->entry
[mid
].set_loc
1316 && sec_info
->entry
[mid
].make_relative
1317 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1318 + sec_info
->entry
[mid
].set_loc
[1]))
1322 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1323 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1324 + sec_info
->entry
[mid
].set_loc
[cnt
])
1325 return (bfd_vma
) -2;
1328 /* Any new augmentation bytes go before the first relocation. */
1329 return (offset
+ sec_info
->entry
[mid
].new_offset
1330 - sec_info
->entry
[mid
].offset
1331 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1332 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1335 /* Write out .eh_frame section. This is called with the relocated
1339 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1340 struct bfd_link_info
*info
,
1344 struct eh_frame_sec_info
*sec_info
;
1345 struct elf_link_hash_table
*htab
;
1346 struct eh_frame_hdr_info
*hdr_info
;
1347 unsigned int ptr_size
;
1348 struct eh_cie_fde
*ent
;
1350 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1351 /* FIXME: octets_per_byte. */
1352 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1353 sec
->output_offset
, sec
->size
);
1355 ptr_size
= (get_elf_backend_data (abfd
)
1356 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1357 BFD_ASSERT (ptr_size
!= 0);
1359 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1360 htab
= elf_hash_table (info
);
1361 hdr_info
= &htab
->eh_info
;
1363 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1364 hdr_info
->array
= (struct eh_frame_array_ent
*)
1365 bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1366 if (hdr_info
->array
== NULL
)
1369 /* The new offsets can be bigger or smaller than the original offsets.
1370 We therefore need to make two passes over the section: one backward
1371 pass to move entries up and one forward pass to move entries down.
1372 The two passes won't interfere with each other because entries are
1374 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1375 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1376 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1378 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1379 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1380 memmove (contents
+ ent
->new_offset
, contents
+ ent
->offset
, ent
->size
);
1382 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1384 unsigned char *buf
, *end
;
1385 unsigned int new_size
;
1392 /* Any terminating FDE must be at the end of the section. */
1393 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1397 buf
= contents
+ ent
->new_offset
;
1398 end
= buf
+ ent
->size
;
1399 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1401 /* Update the size. It may be shrinked. */
1402 bfd_put_32 (abfd
, new_size
- 4, buf
);
1404 /* Filling the extra bytes with DW_CFA_nops. */
1405 if (new_size
!= ent
->size
)
1406 memset (end
, 0, new_size
- ent
->size
);
1411 if (ent
->make_relative
1412 || ent
->u
.cie
.make_lsda_relative
1413 || ent
->u
.cie
.per_encoding_relative
)
1416 unsigned int action
, extra_string
, extra_data
;
1417 unsigned int per_width
, per_encoding
;
1419 /* Need to find 'R' or 'L' augmentation's argument and modify
1420 DW_EH_PE_* value. */
1421 action
= ((ent
->make_relative
? 1 : 0)
1422 | (ent
->u
.cie
.make_lsda_relative
? 2 : 0)
1423 | (ent
->u
.cie
.per_encoding_relative
? 4 : 0));
1424 extra_string
= extra_augmentation_string_bytes (ent
);
1425 extra_data
= extra_augmentation_data_bytes (ent
);
1427 /* Skip length, id and version. */
1430 buf
+= strlen (aug
) + 1;
1431 skip_leb128 (&buf
, end
);
1432 skip_leb128 (&buf
, end
);
1433 skip_leb128 (&buf
, end
);
1436 /* The uleb128 will always be a single byte for the kind
1437 of augmentation strings that we're prepared to handle. */
1438 *buf
++ += extra_data
;
1442 /* Make room for the new augmentation string and data bytes. */
1443 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1444 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1445 buf
+= extra_string
;
1446 end
+= extra_string
+ extra_data
;
1448 if (ent
->add_augmentation_size
)
1451 *buf
++ = extra_data
- 1;
1453 if (ent
->u
.cie
.add_fde_encoding
)
1455 BFD_ASSERT (action
& 1);
1457 *buf
++ = DW_EH_PE_pcrel
;
1467 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1468 *buf
|= DW_EH_PE_pcrel
;
1474 if (ent
->u
.cie
.make_per_encoding_relative
)
1475 *buf
|= DW_EH_PE_pcrel
;
1476 per_encoding
= *buf
++;
1477 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1478 BFD_ASSERT (per_width
!= 0);
1479 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1480 == ent
->u
.cie
.per_encoding_relative
);
1481 if ((per_encoding
& 0x70) == DW_EH_PE_aligned
)
1483 + ((buf
- contents
+ per_width
- 1)
1484 & ~((bfd_size_type
) per_width
- 1)));
1489 val
= read_value (abfd
, buf
, per_width
,
1490 get_DW_EH_PE_signed (per_encoding
));
1491 if (ent
->u
.cie
.make_per_encoding_relative
)
1492 val
-= (sec
->output_section
->vma
1493 + sec
->output_offset
1494 + (buf
- contents
));
1497 val
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1498 val
-= extra_string
+ extra_data
;
1500 write_value (abfd
, buf
, val
, per_width
);
1508 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1509 *buf
|= DW_EH_PE_pcrel
;
1524 bfd_vma value
, address
;
1527 struct eh_cie_fde
*cie
;
1530 cie
= ent
->u
.fde
.cie_inf
;
1532 value
= ((ent
->new_offset
+ sec
->output_offset
+ 4)
1533 - (cie
->new_offset
+ cie
->u
.cie
.u
.sec
->output_offset
));
1534 bfd_put_32 (abfd
, value
, buf
);
1536 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1537 value
= read_value (abfd
, buf
, width
,
1538 get_DW_EH_PE_signed (ent
->fde_encoding
));
1542 switch (ent
->fde_encoding
& 0x70)
1544 case DW_EH_PE_textrel
:
1545 BFD_ASSERT (hdr_info
== NULL
);
1547 case DW_EH_PE_datarel
:
1549 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1551 BFD_ASSERT (got
!= NULL
);
1552 address
+= got
->vma
;
1555 case DW_EH_PE_pcrel
:
1556 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1557 address
+= (sec
->output_section
->vma
1558 + sec
->output_offset
1562 if (ent
->make_relative
)
1563 value
-= (sec
->output_section
->vma
1564 + sec
->output_offset
1565 + ent
->new_offset
+ 8);
1566 write_value (abfd
, buf
, value
, width
);
1573 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1574 hdr_info
->array
[hdr_info
->array_count
++].fde
1575 = (sec
->output_section
->vma
1576 + sec
->output_offset
1580 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
1581 || cie
->u
.cie
.make_lsda_relative
)
1583 buf
+= ent
->lsda_offset
;
1584 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1585 value
= read_value (abfd
, buf
, width
,
1586 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1589 if ((ent
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1590 value
+= (bfd_vma
) ent
->offset
- ent
->new_offset
;
1591 else if (cie
->u
.cie
.make_lsda_relative
)
1592 value
-= (sec
->output_section
->vma
1593 + sec
->output_offset
1594 + ent
->new_offset
+ 8 + ent
->lsda_offset
);
1595 write_value (abfd
, buf
, value
, width
);
1598 else if (ent
->add_augmentation_size
)
1600 /* Skip the PC and length and insert a zero byte for the
1601 augmentation size. */
1603 memmove (buf
+ 1, buf
, end
- buf
);
1609 /* Adjust DW_CFA_set_loc. */
1610 unsigned int cnt
, width
;
1613 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1614 new_offset
= ent
->new_offset
+ 8
1615 + extra_augmentation_string_bytes (ent
)
1616 + extra_augmentation_data_bytes (ent
);
1618 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1621 buf
= start
+ ent
->set_loc
[cnt
];
1623 value
= read_value (abfd
, buf
, width
,
1624 get_DW_EH_PE_signed (ent
->fde_encoding
));
1628 if ((ent
->fde_encoding
& 0x70) == DW_EH_PE_pcrel
)
1629 value
+= (bfd_vma
) ent
->offset
+ 8 - new_offset
;
1630 if (ent
->make_relative
)
1631 value
-= (sec
->output_section
->vma
1632 + sec
->output_offset
1633 + new_offset
+ ent
->set_loc
[cnt
]);
1634 write_value (abfd
, buf
, value
, width
);
1640 /* We don't align the section to its section alignment since the
1641 runtime library only expects all CIE/FDE records aligned at
1642 the pointer size. _bfd_elf_discard_section_eh_frame should
1643 have padded CIE/FDE records to multiple of pointer size with
1644 size_of_output_cie_fde. */
1645 if ((sec
->size
% ptr_size
) != 0)
1648 /* FIXME: octets_per_byte. */
1649 return bfd_set_section_contents (abfd
, sec
->output_section
,
1650 contents
, (file_ptr
) sec
->output_offset
,
1654 /* Helper function used to sort .eh_frame_hdr search table by increasing
1655 VMA of FDE initial location. */
1658 vma_compare (const void *a
, const void *b
)
1660 const struct eh_frame_array_ent
*p
= (const struct eh_frame_array_ent
*) a
;
1661 const struct eh_frame_array_ent
*q
= (const struct eh_frame_array_ent
*) b
;
1662 if (p
->initial_loc
> q
->initial_loc
)
1664 if (p
->initial_loc
< q
->initial_loc
)
1669 /* Write out .eh_frame_hdr section. This must be called after
1670 _bfd_elf_write_section_eh_frame has been called on all input
1672 .eh_frame_hdr format:
1673 ubyte version (currently 1)
1674 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1676 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1677 number (or DW_EH_PE_omit if there is no
1678 binary search table computed))
1679 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1680 or DW_EH_PE_omit if not present.
1681 DW_EH_PE_datarel is using address of
1682 .eh_frame_hdr section start as base)
1683 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1684 optionally followed by:
1685 [encoded] fde_count (total number of FDEs in .eh_frame section)
1686 fde_count x [encoded] initial_loc, fde
1687 (array of encoded pairs containing
1688 FDE initial_location field and FDE address,
1689 sorted by increasing initial_loc). */
1692 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1694 struct elf_link_hash_table
*htab
;
1695 struct eh_frame_hdr_info
*hdr_info
;
1698 asection
*eh_frame_sec
;
1701 bfd_vma encoded_eh_frame
;
1703 htab
= elf_hash_table (info
);
1704 hdr_info
= &htab
->eh_info
;
1705 sec
= hdr_info
->hdr_sec
;
1709 size
= EH_FRAME_HDR_SIZE
;
1710 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1711 size
+= 4 + hdr_info
->fde_count
* 8;
1712 contents
= (bfd_byte
*) bfd_malloc (size
);
1713 if (contents
== NULL
)
1716 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1717 if (eh_frame_sec
== NULL
)
1723 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1724 contents
[0] = 1; /* Version. */
1725 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1726 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1727 &encoded_eh_frame
); /* .eh_frame offset. */
1729 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1731 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1732 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1736 contents
[2] = DW_EH_PE_omit
;
1737 contents
[3] = DW_EH_PE_omit
;
1739 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1741 if (contents
[2] != DW_EH_PE_omit
)
1745 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1746 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1748 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1751 hdr_info
->array
[i
].initial_loc
1752 - sec
->output_section
->vma
,
1753 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1755 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1756 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1760 /* FIXME: octets_per_byte. */
1761 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1762 contents
, (file_ptr
) sec
->output_offset
,
1768 /* Return the width of FDE addresses. This is the default implementation. */
1771 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1773 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1776 /* Decide whether we can use a PC-relative encoding within the given
1777 EH frame section. This is the default implementation. */
1780 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1781 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1782 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1787 /* Select an encoding for the given address. Preference is given to
1788 PC-relative addressing modes. */
1791 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1792 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1793 asection
*osec
, bfd_vma offset
,
1794 asection
*loc_sec
, bfd_vma loc_offset
,
1797 *encoded
= osec
->vma
+ offset
-
1798 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1799 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;