1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
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. */
27 #include "elf/dwarf2.h"
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
;
47 struct eh_cie_fde
*cie_inf
;
48 unsigned char per_encoding
;
49 unsigned char lsda_encoding
;
50 unsigned char fde_encoding
;
51 unsigned char initial_insn_length
;
52 unsigned char make_relative
;
53 unsigned char 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
= e1
;
219 const struct cie
*c2
= 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
= 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
->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;
300 if (entry
->add_augmentation_size
)
302 if (entry
->add_fde_encoding
)
307 if (entry
->u
.fde
.cie_inf
->add_augmentation_size
)
313 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
314 required alignment of ENTRY in bytes. */
317 size_of_output_cie_fde (struct eh_cie_fde
*entry
, unsigned int alignment
)
321 if (entry
->size
== 4)
324 + extra_augmentation_string_bytes (entry
)
325 + extra_augmentation_data_bytes (entry
)
326 + alignment
- 1) & -alignment
;
329 /* Assume that the bytes between *ITER and END are CFA instructions.
330 Try to move *ITER past the first instruction and return true on
331 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
334 skip_cfa_op (bfd_byte
**iter
, bfd_byte
*end
, unsigned int encoded_ptr_width
)
339 if (!read_byte (iter
, end
, &op
))
342 switch (op
& 0xc0 ? op
& 0xc0 : op
)
345 case DW_CFA_advance_loc
:
347 case DW_CFA_remember_state
:
348 case DW_CFA_restore_state
:
349 case DW_CFA_GNU_window_save
:
354 case DW_CFA_restore_extended
:
355 case DW_CFA_undefined
:
356 case DW_CFA_same_value
:
357 case DW_CFA_def_cfa_register
:
358 case DW_CFA_def_cfa_offset
:
359 case DW_CFA_def_cfa_offset_sf
:
360 case DW_CFA_GNU_args_size
:
361 /* One leb128 argument. */
362 return skip_leb128 (iter
, end
);
364 case DW_CFA_val_offset
:
365 case DW_CFA_val_offset_sf
:
366 case DW_CFA_offset_extended
:
367 case DW_CFA_register
:
369 case DW_CFA_offset_extended_sf
:
370 case DW_CFA_GNU_negative_offset_extended
:
371 case DW_CFA_def_cfa_sf
:
372 /* Two leb128 arguments. */
373 return (skip_leb128 (iter
, end
)
374 && skip_leb128 (iter
, end
));
376 case DW_CFA_def_cfa_expression
:
377 /* A variable-length argument. */
378 return (read_uleb128 (iter
, end
, &length
)
379 && skip_bytes (iter
, end
, length
));
381 case DW_CFA_expression
:
382 case DW_CFA_val_expression
:
383 /* A leb128 followed by a variable-length argument. */
384 return (skip_leb128 (iter
, end
)
385 && read_uleb128 (iter
, end
, &length
)
386 && skip_bytes (iter
, end
, length
));
389 return skip_bytes (iter
, end
, encoded_ptr_width
);
391 case DW_CFA_advance_loc1
:
392 return skip_bytes (iter
, end
, 1);
394 case DW_CFA_advance_loc2
:
395 return skip_bytes (iter
, end
, 2);
397 case DW_CFA_advance_loc4
:
398 return skip_bytes (iter
, end
, 4);
400 case DW_CFA_MIPS_advance_loc8
:
401 return skip_bytes (iter
, end
, 8);
408 /* Try to interpret the bytes between BUF and END as CFA instructions.
409 If every byte makes sense, return a pointer to the first DW_CFA_nop
410 padding byte, or END if there is no padding. Return null otherwise.
411 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
414 skip_non_nops (bfd_byte
*buf
, bfd_byte
*end
, unsigned int encoded_ptr_width
,
415 unsigned int *set_loc_count
)
421 if (*buf
== DW_CFA_nop
)
425 if (*buf
== DW_CFA_set_loc
)
427 if (!skip_cfa_op (&buf
, end
, encoded_ptr_width
))
434 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
435 .eh_frame section. */
438 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info
*info
)
440 struct eh_frame_hdr_info
*hdr_info
;
442 hdr_info
= &elf_hash_table (info
)->eh_info
;
443 if (!hdr_info
->parsed_eh_frames
&& !info
->relocatable
)
444 hdr_info
->cies
= htab_try_create (1, cie_hash
, cie_eq
, free
);
447 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
448 information in the section's sec_info field on success. COOKIE
449 describes the relocations in SEC. */
452 _bfd_elf_parse_eh_frame (bfd
*abfd
, struct bfd_link_info
*info
,
453 asection
*sec
, struct elf_reloc_cookie
*cookie
)
455 #define REQUIRE(COND) \
458 goto free_no_table; \
461 bfd_byte
*ehbuf
= NULL
, *buf
, *end
;
463 struct eh_cie_fde
*this_inf
;
464 unsigned int hdr_length
, hdr_id
;
468 struct eh_cie_fde
*local_cie
;
469 } *ecies
= NULL
, *ecie
;
470 unsigned int ecie_count
;
471 struct cie
*cie
, *local_cies
= NULL
, tmp_cie
;
472 struct elf_link_hash_table
*htab
;
473 struct eh_frame_hdr_info
*hdr_info
;
474 struct eh_frame_sec_info
*sec_info
= NULL
;
475 unsigned int ptr_size
;
476 unsigned int num_cies
;
477 unsigned int num_entries
;
478 elf_gc_mark_hook_fn gc_mark_hook
;
480 htab
= elf_hash_table (info
);
481 hdr_info
= &htab
->eh_info
;
482 if (hdr_info
->parsed_eh_frames
)
487 /* This file does not contain .eh_frame information. */
491 if (bfd_is_abs_section (sec
->output_section
))
493 /* At least one of the sections is being discarded from the
494 link, so we should just ignore them. */
498 /* Read the frame unwind information from abfd. */
500 REQUIRE (bfd_malloc_and_get_section (abfd
, sec
, &ehbuf
));
503 && bfd_get_32 (abfd
, ehbuf
) == 0
504 && cookie
->rel
== cookie
->relend
)
506 /* Empty .eh_frame section. */
511 /* If .eh_frame section size doesn't fit into int, we cannot handle
512 it (it would need to use 64-bit .eh_frame format anyway). */
513 REQUIRE (sec
->size
== (unsigned int) sec
->size
);
515 ptr_size
= (get_elf_backend_data (abfd
)
516 ->elf_backend_eh_frame_address_size (abfd
, sec
));
517 REQUIRE (ptr_size
!= 0);
519 /* Go through the section contents and work out how many FDEs and
522 end
= ehbuf
+ sec
->size
;
529 /* Read the length of the entry. */
530 REQUIRE (skip_bytes (&buf
, end
, 4));
531 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
533 /* 64-bit .eh_frame is not supported. */
534 REQUIRE (hdr_length
!= 0xffffffff);
538 REQUIRE (skip_bytes (&buf
, end
, 4));
539 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
543 REQUIRE (skip_bytes (&buf
, end
, hdr_length
- 4));
546 sec_info
= bfd_zmalloc (sizeof (struct eh_frame_sec_info
)
547 + (num_entries
- 1) * sizeof (struct eh_cie_fde
));
550 ecies
= bfd_zmalloc (num_cies
* sizeof (*ecies
));
553 /* If we're not merging CIE entries (such as for a relocatable link),
554 we need to have a "struct cie" for each CIE in this section. */
555 if (hdr_info
->cies
== NULL
)
557 local_cies
= bfd_zmalloc (num_cies
* sizeof (*local_cies
));
558 REQUIRE (local_cies
);
561 #define ENSURE_NO_RELOCS(buf) \
562 REQUIRE (!(cookie->rel < cookie->relend \
563 && (cookie->rel->r_offset \
564 < (bfd_size_type) ((buf) - ehbuf)) \
565 && cookie->rel->r_info != 0))
567 #define SKIP_RELOCS(buf) \
568 while (cookie->rel < cookie->relend \
569 && (cookie->rel->r_offset \
570 < (bfd_size_type) ((buf) - ehbuf))) \
573 #define GET_RELOC(buf) \
574 ((cookie->rel < cookie->relend \
575 && (cookie->rel->r_offset \
576 == (bfd_size_type) ((buf) - ehbuf))) \
577 ? cookie->rel : NULL)
581 gc_mark_hook
= get_elf_backend_data (abfd
)->gc_mark_hook
;
582 while ((bfd_size_type
) (buf
- ehbuf
) != sec
->size
)
585 bfd_byte
*start
, *insns
, *insns_end
;
586 bfd_size_type length
;
587 unsigned int set_loc_count
;
589 this_inf
= sec_info
->entry
+ sec_info
->count
;
592 /* Read the length of the entry. */
593 REQUIRE (skip_bytes (&buf
, ehbuf
+ sec
->size
, 4));
594 hdr_length
= bfd_get_32 (abfd
, buf
- 4);
596 /* The CIE/FDE must be fully contained in this input section. */
597 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) + hdr_length
<= sec
->size
);
598 end
= buf
+ hdr_length
;
600 this_inf
->offset
= last_fde
- ehbuf
;
601 this_inf
->size
= 4 + hdr_length
;
602 this_inf
->reloc_index
= cookie
->rel
- cookie
->rels
;
606 /* A zero-length CIE should only be found at the end of
608 REQUIRE ((bfd_size_type
) (buf
- ehbuf
) == sec
->size
);
609 ENSURE_NO_RELOCS (buf
);
614 REQUIRE (skip_bytes (&buf
, end
, 4));
615 hdr_id
= bfd_get_32 (abfd
, buf
- 4);
619 unsigned int initial_insn_length
;
624 /* If we're merging CIEs, construct the struct cie in TMP_CIE;
625 we'll enter it into the global pool later. Otherwise point
626 CIE to one of the section-local cie structures. */
628 cie
= local_cies
+ ecie_count
;
632 memset (cie
, 0, sizeof (*cie
));
634 cie
->cie_inf
= this_inf
;
635 cie
->length
= hdr_length
;
636 cie
->output_sec
= sec
->output_section
;
638 REQUIRE (read_byte (&buf
, end
, &cie
->version
));
640 /* Cannot handle unknown versions. */
641 REQUIRE (cie
->version
== 1 || cie
->version
== 3);
642 REQUIRE (strlen ((char *) buf
) < sizeof (cie
->augmentation
));
644 strcpy (cie
->augmentation
, (char *) buf
);
645 buf
= (bfd_byte
*) strchr ((char *) buf
, '\0') + 1;
646 ENSURE_NO_RELOCS (buf
);
647 if (buf
[0] == 'e' && buf
[1] == 'h')
649 /* GCC < 3.0 .eh_frame CIE */
650 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
651 is private to each CIE, so we don't need it for anything.
653 REQUIRE (skip_bytes (&buf
, end
, ptr_size
));
656 REQUIRE (read_uleb128 (&buf
, end
, &cie
->code_align
));
657 REQUIRE (read_sleb128 (&buf
, end
, &cie
->data_align
));
658 if (cie
->version
== 1)
661 cie
->ra_column
= *buf
++;
664 REQUIRE (read_uleb128 (&buf
, end
, &cie
->ra_column
));
665 ENSURE_NO_RELOCS (buf
);
666 cie
->lsda_encoding
= DW_EH_PE_omit
;
667 cie
->fde_encoding
= DW_EH_PE_omit
;
668 cie
->per_encoding
= DW_EH_PE_omit
;
669 aug
= cie
->augmentation
;
670 if (aug
[0] != 'e' || aug
[1] != 'h')
675 REQUIRE (read_uleb128 (&buf
, end
, &cie
->augmentation_size
));
676 ENSURE_NO_RELOCS (buf
);
683 REQUIRE (read_byte (&buf
, end
, &cie
->lsda_encoding
));
684 ENSURE_NO_RELOCS (buf
);
685 REQUIRE (get_DW_EH_PE_width (cie
->lsda_encoding
, ptr_size
));
688 REQUIRE (read_byte (&buf
, end
, &cie
->fde_encoding
));
689 ENSURE_NO_RELOCS (buf
);
690 REQUIRE (get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
));
698 REQUIRE (read_byte (&buf
, end
, &cie
->per_encoding
));
699 per_width
= get_DW_EH_PE_width (cie
->per_encoding
,
702 if ((cie
->per_encoding
& 0xf0) == DW_EH_PE_aligned
)
704 length
= -(buf
- ehbuf
) & (per_width
- 1);
705 REQUIRE (skip_bytes (&buf
, end
, length
));
707 ENSURE_NO_RELOCS (buf
);
708 /* Ensure we have a reloc here. */
709 if (GET_RELOC (buf
) != NULL
)
711 unsigned long r_symndx
;
714 if (elf_elfheader (abfd
)->e_ident
[EI_CLASS
]
716 r_symndx
= ELF64_R_SYM (cookie
->rel
->r_info
);
719 r_symndx
= ELF32_R_SYM (cookie
->rel
->r_info
);
720 if (r_symndx
>= cookie
->locsymcount
721 || ELF_ST_BIND (cookie
->locsyms
[r_symndx
]
722 .st_info
) != STB_LOCAL
)
724 struct elf_link_hash_entry
*h
;
726 r_symndx
-= cookie
->extsymoff
;
727 h
= cookie
->sym_hashes
[r_symndx
];
729 while (h
->root
.type
== bfd_link_hash_indirect
730 || h
->root
.type
== bfd_link_hash_warning
)
731 h
= (struct elf_link_hash_entry
*)
734 cie
->personality
.h
= h
;
738 Elf_Internal_Sym
*sym
;
742 sym
= &cookie
->locsyms
[r_symndx
];
743 sym_sec
= (bfd_section_from_elf_index
744 (abfd
, sym
->st_shndx
));
747 if (sym_sec
->kept_section
!= NULL
)
748 sym_sec
= sym_sec
->kept_section
;
749 if (sym_sec
->output_section
!= NULL
)
752 + sym_sec
->output_offset
753 + sym_sec
->output_section
->vma
);
754 cie
->personality
.val
= val
;
755 cie
->local_personality
= 1;
760 /* Cope with MIPS-style composite relocations. */
763 while (GET_RELOC (buf
) != NULL
);
765 REQUIRE (skip_bytes (&buf
, end
, per_width
));
766 REQUIRE (cie
->local_personality
|| cie
->personality
.h
);
770 /* Unrecognized augmentation. Better bail out. */
775 /* For shared libraries, try to get rid of as many RELATIVE relocs
778 && (get_elf_backend_data (abfd
)
779 ->elf_backend_can_make_relative_eh_frame
782 if ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
)
783 cie
->make_relative
= 1;
784 /* If the CIE doesn't already have an 'R' entry, it's fairly
785 easy to add one, provided that there's no aligned data
786 after the augmentation string. */
787 else if (cie
->fde_encoding
== DW_EH_PE_omit
788 && (cie
->per_encoding
& 0xf0) != DW_EH_PE_aligned
)
790 if (*cie
->augmentation
== 0)
791 this_inf
->add_augmentation_size
= 1;
792 this_inf
->add_fde_encoding
= 1;
793 cie
->make_relative
= 1;
798 && (get_elf_backend_data (abfd
)
799 ->elf_backend_can_make_lsda_relative_eh_frame
801 && (cie
->lsda_encoding
& 0xf0) == DW_EH_PE_absptr
)
802 cie
->make_lsda_relative
= 1;
804 /* If FDE encoding was not specified, it defaults to
806 if (cie
->fde_encoding
== DW_EH_PE_omit
)
807 cie
->fde_encoding
= DW_EH_PE_absptr
;
809 initial_insn_length
= end
- buf
;
810 if (initial_insn_length
<= sizeof (cie
->initial_instructions
))
812 cie
->initial_insn_length
= initial_insn_length
;
813 memcpy (cie
->initial_instructions
, buf
, initial_insn_length
);
816 buf
+= initial_insn_length
;
817 ENSURE_NO_RELOCS (buf
);
819 this_inf
->make_relative
= cie
->make_relative
;
820 this_inf
->make_lsda_relative
= cie
->make_lsda_relative
;
821 this_inf
->per_encoding_relative
822 = (cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
;
828 /* Find the corresponding CIE. */
829 unsigned int cie_offset
= this_inf
->offset
+ 4 - hdr_id
;
830 for (ecie
= ecies
; ecie
< ecies
+ ecie_count
; ++ecie
)
831 if (cie_offset
== ecie
->local_cie
->offset
)
834 /* Ensure this FDE references one of the CIEs in this input
836 REQUIRE (ecie
!= ecies
+ ecie_count
);
838 this_inf
->u
.fde
.cie_inf
= ecie
->local_cie
;
840 ENSURE_NO_RELOCS (buf
);
841 REQUIRE (GET_RELOC (buf
));
843 /* Chain together the FDEs for each section. */
844 rsec
= _bfd_elf_gc_mark_rsec (info
, sec
, gc_mark_hook
, cookie
);
845 REQUIRE (rsec
&& rsec
->owner
== abfd
);
846 this_inf
->u
.fde
.next_for_section
= elf_fde_list (rsec
);
847 elf_fde_list (rsec
) = this_inf
;
849 /* Skip the initial location and address range. */
851 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
852 REQUIRE (skip_bytes (&buf
, end
, 2 * length
));
854 /* Skip the augmentation size, if present. */
855 if (cie
->augmentation
[0] == 'z')
856 REQUIRE (read_uleb128 (&buf
, end
, &length
));
860 /* Of the supported augmentation characters above, only 'L'
861 adds augmentation data to the FDE. This code would need to
862 be adjusted if any future augmentations do the same thing. */
863 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
865 this_inf
->lsda_offset
= buf
- start
;
866 /* If there's no 'z' augmentation, we don't know where the
867 CFA insns begin. Assume no padding. */
868 if (cie
->augmentation
[0] != 'z')
872 /* Skip over the augmentation data. */
873 REQUIRE (skip_bytes (&buf
, end
, length
));
876 buf
= last_fde
+ 4 + hdr_length
;
880 /* Try to interpret the CFA instructions and find the first
881 padding nop. Shrink this_inf's size so that it doesn't
882 include the padding. */
883 length
= get_DW_EH_PE_width (cie
->fde_encoding
, ptr_size
);
885 insns_end
= skip_non_nops (insns
, end
, length
, &set_loc_count
);
886 /* If we don't understand the CFA instructions, we can't know
887 what needs to be adjusted there. */
888 if (insns_end
== NULL
889 /* For the time being we don't support DW_CFA_set_loc in
891 || (set_loc_count
&& this_inf
->cie
))
893 this_inf
->size
-= end
- insns_end
;
894 if (insns_end
!= end
&& this_inf
->cie
)
896 cie
->initial_insn_length
-= end
- insns_end
;
897 cie
->length
-= end
- insns_end
;
900 && ((cie
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
901 || cie
->make_relative
))
906 this_inf
->set_loc
= bfd_malloc ((set_loc_count
+ 1)
907 * sizeof (unsigned int));
908 REQUIRE (this_inf
->set_loc
);
909 this_inf
->set_loc
[0] = set_loc_count
;
914 if (*p
== DW_CFA_set_loc
)
915 this_inf
->set_loc
[++cnt
] = p
+ 1 - start
;
916 REQUIRE (skip_cfa_op (&p
, end
, length
));
920 this_inf
->removed
= 1;
921 this_inf
->fde_encoding
= cie
->fde_encoding
;
922 this_inf
->lsda_encoding
= cie
->lsda_encoding
;
925 /* We have now finished constructing the struct cie. */
926 if (hdr_info
->cies
!= NULL
)
928 /* See if we can merge this CIE with an earlier one. */
931 cie_compute_hash (cie
);
932 loc
= htab_find_slot_with_hash (hdr_info
->cies
, cie
,
935 if (*loc
== HTAB_EMPTY_ENTRY
)
937 *loc
= malloc (sizeof (struct cie
));
939 memcpy (*loc
, cie
, sizeof (struct cie
));
941 cie
= (struct cie
*) *loc
;
943 this_inf
->u
.cie
.merged
= cie
->cie_inf
;
944 ecies
[ecie_count
].cie
= cie
;
945 ecies
[ecie_count
++].local_cie
= this_inf
;
949 BFD_ASSERT (sec_info
->count
== num_entries
);
950 BFD_ASSERT (ecie_count
== num_cies
);
952 elf_section_data (sec
)->sec_info
= sec_info
;
953 sec
->sec_info_type
= ELF_INFO_TYPE_EH_FRAME
;
957 (*info
->callbacks
->einfo
)
958 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
960 hdr_info
->table
= FALSE
;
973 /* Finish a pass over all .eh_frame sections. */
976 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info
*info
)
978 struct eh_frame_hdr_info
*hdr_info
;
980 hdr_info
= &elf_hash_table (info
)->eh_info
;
981 if (hdr_info
->cies
!= NULL
)
983 htab_delete (hdr_info
->cies
);
984 hdr_info
->cies
= NULL
;
986 hdr_info
->parsed_eh_frames
= TRUE
;
989 /* Mark all relocations against CIE or FDE ENT, which occurs in
990 .eh_frame section SEC. COOKIE describes the relocations in SEC;
991 its "rel" field can be changed freely. */
994 mark_entry (struct bfd_link_info
*info
, asection
*sec
,
995 struct eh_cie_fde
*ent
, elf_gc_mark_hook_fn gc_mark_hook
,
996 struct elf_reloc_cookie
*cookie
)
998 for (cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
999 cookie
->rel
< cookie
->relend
1000 && cookie
->rel
->r_offset
< ent
->offset
+ ent
->size
;
1002 if (!_bfd_elf_gc_mark_reloc (info
, sec
, gc_mark_hook
, cookie
))
1008 /* Mark all the relocations against FDEs that relate to code in input
1009 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1010 relocations are described by COOKIE. */
1013 _bfd_elf_gc_mark_fdes (struct bfd_link_info
*info
, asection
*sec
,
1014 asection
*eh_frame
, elf_gc_mark_hook_fn gc_mark_hook
,
1015 struct elf_reloc_cookie
*cookie
)
1017 struct eh_cie_fde
*fde
, *cie
, *merged
;
1019 for (fde
= elf_fde_list (sec
); fde
; fde
= fde
->u
.fde
.next_for_section
)
1021 if (!mark_entry (info
, eh_frame
, fde
, gc_mark_hook
, cookie
))
1024 /* At this stage, all cie_inf fields point to local CIEs, so we
1025 can use the same cookie to refer to them. */
1026 cie
= fde
->u
.fde
.cie_inf
;
1027 merged
= cie
->u
.cie
.merged
;
1028 if (!merged
->u
.cie
.gc_mark
)
1030 merged
->u
.cie
.gc_mark
= 1;
1031 if (!mark_entry (info
, eh_frame
, cie
, gc_mark_hook
, cookie
))
1038 /* This function is called for each input file before the .eh_frame
1039 section is relocated. It discards duplicate CIEs and FDEs for discarded
1040 functions. The function returns TRUE iff any entries have been
1044 _bfd_elf_discard_section_eh_frame
1045 (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
1046 bfd_boolean (*reloc_symbol_deleted_p
) (bfd_vma
, void *),
1047 struct elf_reloc_cookie
*cookie
)
1049 struct eh_cie_fde
*ent
, *cie
, *merged
;
1050 struct eh_frame_sec_info
*sec_info
;
1051 struct eh_frame_hdr_info
*hdr_info
;
1052 unsigned int ptr_size
, offset
;
1054 sec_info
= (struct eh_frame_sec_info
*) elf_section_data (sec
)->sec_info
;
1055 if (sec_info
== NULL
)
1058 hdr_info
= &elf_hash_table (info
)->eh_info
;
1059 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1062 cookie
->rel
= cookie
->rels
+ ent
->reloc_index
;
1063 BFD_ASSERT (cookie
->rel
< cookie
->relend
1064 && cookie
->rel
->r_offset
== ent
->offset
+ 8);
1065 if (!(*reloc_symbol_deleted_p
) (ent
->offset
+ 8, cookie
))
1068 && (((ent
->fde_encoding
& 0xf0) == DW_EH_PE_absptr
1069 && ent
->u
.fde
.cie_inf
->make_relative
== 0)
1070 || (ent
->fde_encoding
& 0xf0) == DW_EH_PE_aligned
))
1072 /* If a shared library uses absolute pointers
1073 which we cannot turn into PC relative,
1074 don't create the binary search table,
1075 since it is affected by runtime relocations. */
1076 hdr_info
->table
= FALSE
;
1077 (*info
->callbacks
->einfo
)
1078 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1079 " table being created.\n"), abfd
, sec
);
1082 hdr_info
->fde_count
++;
1084 cie
= ent
->u
.fde
.cie_inf
;
1087 merged
= cie
->u
.cie
.merged
;
1088 if (!merged
->removed
)
1089 /* We have decided to keep the group representative. */
1090 ent
->u
.fde
.cie_inf
= merged
;
1091 else if (merged
->u
.cie
.merged
!= merged
)
1092 /* We didn't keep the original group representative,
1093 but we did keep an alternative. */
1094 ent
->u
.fde
.cie_inf
= merged
->u
.cie
.merged
;
1097 /* Make the local CIE represent the merged group. */
1098 merged
->u
.cie
.merged
= cie
;
1105 ptr_size
= (get_elf_backend_data (sec
->owner
)
1106 ->elf_backend_eh_frame_address_size (sec
->owner
, sec
));
1108 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1111 ent
->new_offset
= offset
;
1112 offset
+= size_of_output_cie_fde (ent
, ptr_size
);
1115 sec
->rawsize
= sec
->size
;
1117 return offset
!= sec
->rawsize
;
1120 /* This function is called for .eh_frame_hdr section after
1121 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1122 input sections. It finalizes the size of .eh_frame_hdr section. */
1125 _bfd_elf_discard_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1127 struct elf_link_hash_table
*htab
;
1128 struct eh_frame_hdr_info
*hdr_info
;
1131 htab
= elf_hash_table (info
);
1132 hdr_info
= &htab
->eh_info
;
1134 sec
= hdr_info
->hdr_sec
;
1138 sec
->size
= EH_FRAME_HDR_SIZE
;
1139 if (hdr_info
->table
)
1140 sec
->size
+= 4 + hdr_info
->fde_count
* 8;
1142 elf_tdata (abfd
)->eh_frame_hdr
= sec
;
1146 /* This function is called from size_dynamic_sections.
1147 It needs to decide whether .eh_frame_hdr should be output or not,
1148 because when the dynamic symbol table has been sized it is too late
1149 to strip sections. */
1152 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info
*info
)
1156 struct elf_link_hash_table
*htab
;
1157 struct eh_frame_hdr_info
*hdr_info
;
1159 htab
= elf_hash_table (info
);
1160 hdr_info
= &htab
->eh_info
;
1161 if (hdr_info
->hdr_sec
== NULL
)
1164 if (bfd_is_abs_section (hdr_info
->hdr_sec
->output_section
))
1166 hdr_info
->hdr_sec
= NULL
;
1171 if (info
->eh_frame_hdr
)
1172 for (abfd
= info
->input_bfds
; abfd
!= NULL
; abfd
= abfd
->link_next
)
1174 /* Count only sections which have at least a single CIE or FDE.
1175 There cannot be any CIE or FDE <= 8 bytes. */
1176 o
= bfd_get_section_by_name (abfd
, ".eh_frame");
1177 if (o
&& o
->size
> 8 && !bfd_is_abs_section (o
->output_section
))
1183 hdr_info
->hdr_sec
->flags
|= SEC_EXCLUDE
;
1184 hdr_info
->hdr_sec
= NULL
;
1188 hdr_info
->table
= TRUE
;
1192 /* Adjust an address in the .eh_frame section. Given OFFSET within
1193 SEC, this returns the new offset in the adjusted .eh_frame section,
1194 or -1 if the address refers to a CIE/FDE which has been removed
1195 or to offset with dynamic relocation which is no longer needed. */
1198 _bfd_elf_eh_frame_section_offset (bfd
*output_bfd ATTRIBUTE_UNUSED
,
1199 struct bfd_link_info
*info
,
1203 struct eh_frame_sec_info
*sec_info
;
1204 struct elf_link_hash_table
*htab
;
1205 struct eh_frame_hdr_info
*hdr_info
;
1206 unsigned int lo
, hi
, mid
;
1208 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1210 sec_info
= elf_section_data (sec
)->sec_info
;
1212 if (offset
>= sec
->rawsize
)
1213 return offset
- sec
->rawsize
+ sec
->size
;
1215 htab
= elf_hash_table (info
);
1216 hdr_info
= &htab
->eh_info
;
1217 if (hdr_info
->offsets_adjusted
)
1218 offset
+= sec
->output_offset
;
1221 hi
= sec_info
->count
;
1225 mid
= (lo
+ hi
) / 2;
1226 if (offset
< sec_info
->entry
[mid
].offset
)
1229 >= sec_info
->entry
[mid
].offset
+ sec_info
->entry
[mid
].size
)
1235 BFD_ASSERT (lo
< hi
);
1237 /* FDE or CIE was removed. */
1238 if (sec_info
->entry
[mid
].removed
)
1239 return (bfd_vma
) -1;
1241 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1242 relocation against FDE's initial_location field. */
1243 if (!sec_info
->entry
[mid
].cie
1244 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->make_relative
1245 && offset
== sec_info
->entry
[mid
].offset
+ 8)
1246 return (bfd_vma
) -2;
1248 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1249 for run-time relocation against LSDA field. */
1250 if (!sec_info
->entry
[mid
].cie
1251 && sec_info
->entry
[mid
].u
.fde
.cie_inf
->make_lsda_relative
1252 && (offset
== (sec_info
->entry
[mid
].offset
+ 8
1253 + sec_info
->entry
[mid
].lsda_offset
))
1254 && (sec_info
->entry
[mid
].u
.fde
.cie_inf
->need_lsda_relative
1255 || !hdr_info
->offsets_adjusted
))
1257 sec_info
->entry
[mid
].u
.fde
.cie_inf
->need_lsda_relative
= 1;
1258 return (bfd_vma
) -2;
1261 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1262 relocation against DW_CFA_set_loc's arguments. */
1263 if (sec_info
->entry
[mid
].set_loc
1264 && (sec_info
->entry
[mid
].cie
1265 ? sec_info
->entry
[mid
].make_relative
1266 : sec_info
->entry
[mid
].u
.fde
.cie_inf
->make_relative
)
1267 && (offset
>= sec_info
->entry
[mid
].offset
+ 8
1268 + sec_info
->entry
[mid
].set_loc
[1]))
1272 for (cnt
= 1; cnt
<= sec_info
->entry
[mid
].set_loc
[0]; cnt
++)
1273 if (offset
== sec_info
->entry
[mid
].offset
+ 8
1274 + sec_info
->entry
[mid
].set_loc
[cnt
])
1275 return (bfd_vma
) -2;
1278 if (hdr_info
->offsets_adjusted
)
1279 offset
-= sec
->output_offset
;
1280 /* Any new augmentation bytes go before the first relocation. */
1281 return (offset
+ sec_info
->entry
[mid
].new_offset
1282 - sec_info
->entry
[mid
].offset
1283 + extra_augmentation_string_bytes (sec_info
->entry
+ mid
)
1284 + extra_augmentation_data_bytes (sec_info
->entry
+ mid
));
1287 /* Write out .eh_frame section. This is called with the relocated
1291 _bfd_elf_write_section_eh_frame (bfd
*abfd
,
1292 struct bfd_link_info
*info
,
1296 struct eh_frame_sec_info
*sec_info
;
1297 struct elf_link_hash_table
*htab
;
1298 struct eh_frame_hdr_info
*hdr_info
;
1299 unsigned int ptr_size
;
1300 struct eh_cie_fde
*ent
;
1302 if (sec
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1303 return bfd_set_section_contents (abfd
, sec
->output_section
, contents
,
1304 sec
->output_offset
, sec
->size
);
1306 ptr_size
= (get_elf_backend_data (abfd
)
1307 ->elf_backend_eh_frame_address_size (abfd
, sec
));
1308 BFD_ASSERT (ptr_size
!= 0);
1310 sec_info
= elf_section_data (sec
)->sec_info
;
1311 htab
= elf_hash_table (info
);
1312 hdr_info
= &htab
->eh_info
;
1314 /* First convert all offsets to output section offsets, so that a
1315 CIE offset is valid if the CIE is used by a FDE from some other
1316 section. This can happen when duplicate CIEs are deleted in
1317 _bfd_elf_discard_section_eh_frame. We do all sections here because
1318 this function might not be called on sections in the same order as
1319 _bfd_elf_discard_section_eh_frame. */
1320 if (!hdr_info
->offsets_adjusted
)
1324 struct eh_frame_sec_info
*eh_inf
;
1326 for (ibfd
= info
->input_bfds
; ibfd
!= NULL
; ibfd
= ibfd
->link_next
)
1328 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1329 || (ibfd
->flags
& DYNAMIC
) != 0)
1332 eh
= bfd_get_section_by_name (ibfd
, ".eh_frame");
1333 if (eh
== NULL
|| eh
->sec_info_type
!= ELF_INFO_TYPE_EH_FRAME
)
1336 eh_inf
= elf_section_data (eh
)->sec_info
;
1337 for (ent
= eh_inf
->entry
; ent
< eh_inf
->entry
+ eh_inf
->count
; ++ent
)
1339 ent
->offset
+= eh
->output_offset
;
1340 ent
->new_offset
+= eh
->output_offset
;
1343 hdr_info
->offsets_adjusted
= TRUE
;
1346 if (hdr_info
->table
&& hdr_info
->array
== NULL
)
1348 = bfd_malloc (hdr_info
->fde_count
* sizeof(*hdr_info
->array
));
1349 if (hdr_info
->array
== NULL
)
1352 /* The new offsets can be bigger or smaller than the original offsets.
1353 We therefore need to make two passes over the section: one backward
1354 pass to move entries up and one forward pass to move entries down.
1355 The two passes won't interfere with each other because entries are
1357 for (ent
= sec_info
->entry
+ sec_info
->count
; ent
-- != sec_info
->entry
;)
1358 if (!ent
->removed
&& ent
->new_offset
> ent
->offset
)
1359 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1360 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1362 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1363 if (!ent
->removed
&& ent
->new_offset
< ent
->offset
)
1364 memmove (contents
+ ent
->new_offset
- sec
->output_offset
,
1365 contents
+ ent
->offset
- sec
->output_offset
, ent
->size
);
1367 for (ent
= sec_info
->entry
; ent
< sec_info
->entry
+ sec_info
->count
; ++ent
)
1369 unsigned char *buf
, *end
;
1370 unsigned int new_size
;
1377 /* Any terminating FDE must be at the end of the section. */
1378 BFD_ASSERT (ent
== sec_info
->entry
+ sec_info
->count
- 1);
1382 buf
= contents
+ ent
->new_offset
- sec
->output_offset
;
1383 end
= buf
+ ent
->size
;
1384 new_size
= size_of_output_cie_fde (ent
, ptr_size
);
1386 /* Update the size. It may be shrinked. */
1387 bfd_put_32 (abfd
, new_size
- 4, buf
);
1389 /* Filling the extra bytes with DW_CFA_nops. */
1390 if (new_size
!= ent
->size
)
1391 memset (end
, 0, new_size
- ent
->size
);
1396 if (ent
->make_relative
1397 || ent
->need_lsda_relative
1398 || ent
->per_encoding_relative
)
1401 unsigned int action
, extra_string
, extra_data
;
1402 unsigned int per_width
, per_encoding
;
1404 /* Need to find 'R' or 'L' augmentation's argument and modify
1405 DW_EH_PE_* value. */
1406 action
= ((ent
->make_relative
? 1 : 0)
1407 | (ent
->need_lsda_relative
? 2 : 0)
1408 | (ent
->per_encoding_relative
? 4 : 0));
1409 extra_string
= extra_augmentation_string_bytes (ent
);
1410 extra_data
= extra_augmentation_data_bytes (ent
);
1412 /* Skip length, id and version. */
1415 buf
+= strlen (aug
) + 1;
1416 skip_leb128 (&buf
, end
);
1417 skip_leb128 (&buf
, end
);
1418 skip_leb128 (&buf
, end
);
1421 /* The uleb128 will always be a single byte for the kind
1422 of augmentation strings that we're prepared to handle. */
1423 *buf
++ += extra_data
;
1427 /* Make room for the new augmentation string and data bytes. */
1428 memmove (buf
+ extra_string
+ extra_data
, buf
, end
- buf
);
1429 memmove (aug
+ extra_string
, aug
, buf
- (bfd_byte
*) aug
);
1430 buf
+= extra_string
;
1431 end
+= extra_string
+ extra_data
;
1433 if (ent
->add_augmentation_size
)
1436 *buf
++ = extra_data
- 1;
1438 if (ent
->add_fde_encoding
)
1440 BFD_ASSERT (action
& 1);
1442 *buf
++ = DW_EH_PE_pcrel
;
1452 BFD_ASSERT (*buf
== ent
->lsda_encoding
);
1453 *buf
|= DW_EH_PE_pcrel
;
1459 per_encoding
= *buf
++;
1460 per_width
= get_DW_EH_PE_width (per_encoding
, ptr_size
);
1461 BFD_ASSERT (per_width
!= 0);
1462 BFD_ASSERT (((per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1463 == ent
->per_encoding_relative
);
1464 if ((per_encoding
& 0xf0) == DW_EH_PE_aligned
)
1466 + ((buf
- contents
+ per_width
- 1)
1467 & ~((bfd_size_type
) per_width
- 1)));
1472 val
= read_value (abfd
, buf
, per_width
,
1473 get_DW_EH_PE_signed (per_encoding
));
1474 val
+= ent
->offset
- ent
->new_offset
;
1475 val
-= extra_string
+ extra_data
;
1476 write_value (abfd
, buf
, val
, per_width
);
1484 BFD_ASSERT (*buf
== ent
->fde_encoding
);
1485 *buf
|= DW_EH_PE_pcrel
;
1500 bfd_vma value
, address
;
1503 struct eh_cie_fde
*cie
;
1506 cie
= ent
->u
.fde
.cie_inf
;
1508 value
= ent
->new_offset
+ 4 - cie
->new_offset
;
1509 bfd_put_32 (abfd
, value
, buf
);
1511 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1512 value
= read_value (abfd
, buf
, width
,
1513 get_DW_EH_PE_signed (ent
->fde_encoding
));
1517 switch (ent
->fde_encoding
& 0xf0)
1519 case DW_EH_PE_indirect
:
1520 case DW_EH_PE_textrel
:
1521 BFD_ASSERT (hdr_info
== NULL
);
1523 case DW_EH_PE_datarel
:
1525 asection
*got
= bfd_get_section_by_name (abfd
, ".got");
1527 BFD_ASSERT (got
!= NULL
);
1528 address
+= got
->vma
;
1531 case DW_EH_PE_pcrel
:
1532 value
+= ent
->offset
- ent
->new_offset
;
1533 address
+= sec
->output_section
->vma
+ ent
->offset
+ 8;
1536 if (cie
->make_relative
)
1537 value
-= sec
->output_section
->vma
+ ent
->new_offset
+ 8;
1538 write_value (abfd
, buf
, value
, width
);
1545 hdr_info
->array
[hdr_info
->array_count
].initial_loc
= address
;
1546 hdr_info
->array
[hdr_info
->array_count
++].fde
1547 = sec
->output_section
->vma
+ ent
->new_offset
;
1550 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
1551 || cie
->need_lsda_relative
)
1553 buf
+= ent
->lsda_offset
;
1554 width
= get_DW_EH_PE_width (ent
->lsda_encoding
, ptr_size
);
1555 value
= read_value (abfd
, buf
, width
,
1556 get_DW_EH_PE_signed (ent
->lsda_encoding
));
1559 if ((ent
->lsda_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1560 value
+= ent
->offset
- ent
->new_offset
;
1561 else if (cie
->need_lsda_relative
)
1562 value
-= (sec
->output_section
->vma
+ ent
->new_offset
+ 8
1563 + ent
->lsda_offset
);
1564 write_value (abfd
, buf
, value
, width
);
1567 else if (cie
->add_augmentation_size
)
1569 /* Skip the PC and length and insert a zero byte for the
1570 augmentation size. */
1572 memmove (buf
+ 1, buf
, end
- buf
);
1578 /* Adjust DW_CFA_set_loc. */
1579 unsigned int cnt
, width
;
1582 width
= get_DW_EH_PE_width (ent
->fde_encoding
, ptr_size
);
1583 new_offset
= ent
->new_offset
+ 8
1584 + extra_augmentation_string_bytes (ent
)
1585 + extra_augmentation_data_bytes (ent
);
1587 for (cnt
= 1; cnt
<= ent
->set_loc
[0]; cnt
++)
1590 buf
= start
+ ent
->set_loc
[cnt
];
1592 value
= read_value (abfd
, buf
, width
,
1593 get_DW_EH_PE_signed (ent
->fde_encoding
));
1597 if ((ent
->fde_encoding
& 0xf0) == DW_EH_PE_pcrel
)
1598 value
+= ent
->offset
+ 8 - new_offset
;
1599 if (cie
->make_relative
)
1600 value
-= sec
->output_section
->vma
+ new_offset
1601 + ent
->set_loc
[cnt
];
1602 write_value (abfd
, buf
, value
, width
);
1608 /* We don't align the section to its section alignment since the
1609 runtime library only expects all CIE/FDE records aligned at
1610 the pointer size. _bfd_elf_discard_section_eh_frame should
1611 have padded CIE/FDE records to multiple of pointer size with
1612 size_of_output_cie_fde. */
1613 if ((sec
->size
% ptr_size
) != 0)
1616 return bfd_set_section_contents (abfd
, sec
->output_section
,
1617 contents
, (file_ptr
) sec
->output_offset
,
1621 /* Helper function used to sort .eh_frame_hdr search table by increasing
1622 VMA of FDE initial location. */
1625 vma_compare (const void *a
, const void *b
)
1627 const struct eh_frame_array_ent
*p
= a
;
1628 const struct eh_frame_array_ent
*q
= b
;
1629 if (p
->initial_loc
> q
->initial_loc
)
1631 if (p
->initial_loc
< q
->initial_loc
)
1636 /* Write out .eh_frame_hdr section. This must be called after
1637 _bfd_elf_write_section_eh_frame has been called on all input
1639 .eh_frame_hdr format:
1640 ubyte version (currently 1)
1641 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1643 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1644 number (or DW_EH_PE_omit if there is no
1645 binary search table computed))
1646 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1647 or DW_EH_PE_omit if not present.
1648 DW_EH_PE_datarel is using address of
1649 .eh_frame_hdr section start as base)
1650 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1651 optionally followed by:
1652 [encoded] fde_count (total number of FDEs in .eh_frame section)
1653 fde_count x [encoded] initial_loc, fde
1654 (array of encoded pairs containing
1655 FDE initial_location field and FDE address,
1656 sorted by increasing initial_loc). */
1659 _bfd_elf_write_section_eh_frame_hdr (bfd
*abfd
, struct bfd_link_info
*info
)
1661 struct elf_link_hash_table
*htab
;
1662 struct eh_frame_hdr_info
*hdr_info
;
1665 asection
*eh_frame_sec
;
1668 bfd_vma encoded_eh_frame
;
1670 htab
= elf_hash_table (info
);
1671 hdr_info
= &htab
->eh_info
;
1672 sec
= hdr_info
->hdr_sec
;
1676 size
= EH_FRAME_HDR_SIZE
;
1677 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1678 size
+= 4 + hdr_info
->fde_count
* 8;
1679 contents
= bfd_malloc (size
);
1680 if (contents
== NULL
)
1683 eh_frame_sec
= bfd_get_section_by_name (abfd
, ".eh_frame");
1684 if (eh_frame_sec
== NULL
)
1690 memset (contents
, 0, EH_FRAME_HDR_SIZE
);
1691 contents
[0] = 1; /* Version. */
1692 contents
[1] = get_elf_backend_data (abfd
)->elf_backend_encode_eh_address
1693 (abfd
, info
, eh_frame_sec
, 0, sec
, 4,
1694 &encoded_eh_frame
); /* .eh_frame offset. */
1696 if (hdr_info
->array
&& hdr_info
->array_count
== hdr_info
->fde_count
)
1698 contents
[2] = DW_EH_PE_udata4
; /* FDE count encoding. */
1699 contents
[3] = DW_EH_PE_datarel
| DW_EH_PE_sdata4
; /* Search table enc. */
1703 contents
[2] = DW_EH_PE_omit
;
1704 contents
[3] = DW_EH_PE_omit
;
1706 bfd_put_32 (abfd
, encoded_eh_frame
, contents
+ 4);
1708 if (contents
[2] != DW_EH_PE_omit
)
1712 bfd_put_32 (abfd
, hdr_info
->fde_count
, contents
+ EH_FRAME_HDR_SIZE
);
1713 qsort (hdr_info
->array
, hdr_info
->fde_count
, sizeof (*hdr_info
->array
),
1715 for (i
= 0; i
< hdr_info
->fde_count
; i
++)
1718 hdr_info
->array
[i
].initial_loc
1719 - sec
->output_section
->vma
,
1720 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 4);
1722 hdr_info
->array
[i
].fde
- sec
->output_section
->vma
,
1723 contents
+ EH_FRAME_HDR_SIZE
+ i
* 8 + 8);
1727 retval
= bfd_set_section_contents (abfd
, sec
->output_section
,
1728 contents
, (file_ptr
) sec
->output_offset
,
1734 /* Return the width of FDE addresses. This is the default implementation. */
1737 _bfd_elf_eh_frame_address_size (bfd
*abfd
, asection
*sec ATTRIBUTE_UNUSED
)
1739 return elf_elfheader (abfd
)->e_ident
[EI_CLASS
] == ELFCLASS64
? 8 : 4;
1742 /* Decide whether we can use a PC-relative encoding within the given
1743 EH frame section. This is the default implementation. */
1746 _bfd_elf_can_make_relative (bfd
*input_bfd ATTRIBUTE_UNUSED
,
1747 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1748 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
1753 /* Select an encoding for the given address. Preference is given to
1754 PC-relative addressing modes. */
1757 _bfd_elf_encode_eh_address (bfd
*abfd ATTRIBUTE_UNUSED
,
1758 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1759 asection
*osec
, bfd_vma offset
,
1760 asection
*loc_sec
, bfd_vma loc_offset
,
1763 *encoded
= osec
->vma
+ offset
-
1764 (loc_sec
->output_section
->vma
+ loc_sec
->output_offset
+ loc_offset
);
1765 return DW_EH_PE_pcrel
| DW_EH_PE_sdata4
;