1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Written by Jakub Jelinek <jakub@redhat.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #define EH_FRAME_HDR_SIZE 8
34 unsigned char version;
35 unsigned char local_personality;
36 char augmentation[20];
38 bfd_signed_vma data_align;
40 bfd_vma augmentation_size;
42 struct elf_link_hash_entry *h;
47 unsigned int reloc_index;
49 struct eh_cie_fde *cie_inf;
50 unsigned char per_encoding;
51 unsigned char lsda_encoding;
52 unsigned char fde_encoding;
53 unsigned char initial_insn_length;
54 unsigned char can_make_lsda_relative;
55 unsigned char initial_instructions[50];
60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
61 move onto the next byte. Return true on success. */
63 static inline bfd_boolean
64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
68 *result = *((*iter)++);
72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
73 Return true it was possible to move LENGTH bytes. */
75 static inline bfd_boolean
76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
78 if ((bfd_size_type) (end - *iter) < length)
87 /* Move *ITER over an leb128, stopping at END. Return true if the end
88 of the leb128 was found. */
91 skip_leb128 (bfd_byte **iter, bfd_byte *end)
95 if (!read_byte (iter, end, &byte))
101 /* Like skip_leb128, but treat the leb128 as an unsigned value and
102 store it in *VALUE. */
105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
110 if (!skip_leb128 (iter, end))
116 *value = (*value << 7) | (*--p & 0x7f);
121 /* Like read_uleb128, but for signed values. */
124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
129 if (!skip_leb128 (iter, end))
133 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
135 *value = (*value << 7) | (*--p & 0x7f);
140 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
143 int get_DW_EH_PE_width (int encoding, int ptr_size)
145 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
147 if ((encoding & 0x60) == 0x60)
150 switch (encoding & 7)
152 case DW_EH_PE_udata2: return 2;
153 case DW_EH_PE_udata4: return 4;
154 case DW_EH_PE_udata8: return 8;
155 case DW_EH_PE_absptr: return ptr_size;
163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
165 /* Read a width sized value from memory. */
168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
176 value = bfd_get_signed_16 (abfd, buf);
178 value = bfd_get_16 (abfd, buf);
182 value = bfd_get_signed_32 (abfd, buf);
184 value = bfd_get_32 (abfd, buf);
188 value = bfd_get_signed_64 (abfd, buf);
190 value = bfd_get_64 (abfd, buf);
200 /* Store a width sized value to memory. */
203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
207 case 2: bfd_put_16 (abfd, value, buf); break;
208 case 4: bfd_put_32 (abfd, value, buf); break;
209 case 8: bfd_put_64 (abfd, value, buf); break;
210 default: BFD_FAIL ();
214 /* Return one if C1 and C2 CIEs can be merged. */
217 cie_eq (const void *e1, const void *e2)
219 const struct cie *c1 = (const struct cie *) e1;
220 const struct cie *c2 = (const struct cie *) e2;
222 if (c1->hash == c2->hash
223 && c1->length == c2->length
224 && c1->version == c2->version
225 && c1->local_personality == c2->local_personality
226 && strcmp (c1->augmentation, c2->augmentation) == 0
227 && strcmp (c1->augmentation, "eh") != 0
228 && c1->code_align == c2->code_align
229 && c1->data_align == c2->data_align
230 && c1->ra_column == c2->ra_column
231 && c1->augmentation_size == c2->augmentation_size
232 && memcmp (&c1->personality, &c2->personality,
233 sizeof (c1->personality)) == 0
234 && (c1->cie_inf->u.cie.u.sec->output_section
235 == c2->cie_inf->u.cie.u.sec->output_section)
236 && c1->per_encoding == c2->per_encoding
237 && c1->lsda_encoding == c2->lsda_encoding
238 && c1->fde_encoding == c2->fde_encoding
239 && c1->initial_insn_length == c2->initial_insn_length
240 && c1->initial_insn_length <= sizeof (c1->initial_instructions)
241 && memcmp (c1->initial_instructions,
242 c2->initial_instructions,
243 c1->initial_insn_length) == 0)
250 cie_hash (const void *e)
252 const struct cie *c = (const struct cie *) e;
257 cie_compute_hash (struct cie *c)
261 h = iterative_hash_object (c->length, h);
262 h = iterative_hash_object (c->version, h);
263 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
264 h = iterative_hash_object (c->code_align, h);
265 h = iterative_hash_object (c->data_align, h);
266 h = iterative_hash_object (c->ra_column, h);
267 h = iterative_hash_object (c->augmentation_size, h);
268 h = iterative_hash_object (c->personality, h);
269 h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
270 h = iterative_hash_object (c->per_encoding, h);
271 h = iterative_hash_object (c->lsda_encoding, h);
272 h = iterative_hash_object (c->fde_encoding, h);
273 h = iterative_hash_object (c->initial_insn_length, h);
274 len = c->initial_insn_length;
275 if (len > sizeof (c->initial_instructions))
276 len = sizeof (c->initial_instructions);
277 h = iterative_hash (c->initial_instructions, len, h);
282 /* Return the number of extra bytes that we'll be inserting into
283 ENTRY's augmentation string. */
285 static INLINE unsigned int
286 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
288 unsigned int size = 0;
291 if (entry->add_augmentation_size)
293 if (entry->u.cie.add_fde_encoding)
299 /* Likewise ENTRY's augmentation data. */
301 static INLINE unsigned int
302 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
304 unsigned int size = 0;
305 if (entry->add_augmentation_size)
307 if (entry->cie && entry->u.cie.add_fde_encoding)
312 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
313 required alignment of ENTRY in bytes. */
316 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
320 if (entry->size == 4)
323 + extra_augmentation_string_bytes (entry)
324 + extra_augmentation_data_bytes (entry)
325 + alignment - 1) & -alignment;
328 /* Assume that the bytes between *ITER and END are CFA instructions.
329 Try to move *ITER past the first instruction and return true on
330 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
333 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
338 if (!read_byte (iter, end, &op))
341 switch (op & 0xc0 ? op & 0xc0 : op)
344 case DW_CFA_advance_loc:
346 case DW_CFA_remember_state:
347 case DW_CFA_restore_state:
348 case DW_CFA_GNU_window_save:
353 case DW_CFA_restore_extended:
354 case DW_CFA_undefined:
355 case DW_CFA_same_value:
356 case DW_CFA_def_cfa_register:
357 case DW_CFA_def_cfa_offset:
358 case DW_CFA_def_cfa_offset_sf:
359 case DW_CFA_GNU_args_size:
360 /* One leb128 argument. */
361 return skip_leb128 (iter, end);
363 case DW_CFA_val_offset:
364 case DW_CFA_val_offset_sf:
365 case DW_CFA_offset_extended:
366 case DW_CFA_register:
368 case DW_CFA_offset_extended_sf:
369 case DW_CFA_GNU_negative_offset_extended:
370 case DW_CFA_def_cfa_sf:
371 /* Two leb128 arguments. */
372 return (skip_leb128 (iter, end)
373 && skip_leb128 (iter, end));
375 case DW_CFA_def_cfa_expression:
376 /* A variable-length argument. */
377 return (read_uleb128 (iter, end, &length)
378 && skip_bytes (iter, end, length));
380 case DW_CFA_expression:
381 case DW_CFA_val_expression:
382 /* A leb128 followed by a variable-length argument. */
383 return (skip_leb128 (iter, end)
384 && read_uleb128 (iter, end, &length)
385 && skip_bytes (iter, end, length));
388 return skip_bytes (iter, end, encoded_ptr_width);
390 case DW_CFA_advance_loc1:
391 return skip_bytes (iter, end, 1);
393 case DW_CFA_advance_loc2:
394 return skip_bytes (iter, end, 2);
396 case DW_CFA_advance_loc4:
397 return skip_bytes (iter, end, 4);
399 case DW_CFA_MIPS_advance_loc8:
400 return skip_bytes (iter, end, 8);
407 /* Try to interpret the bytes between BUF and END as CFA instructions.
408 If every byte makes sense, return a pointer to the first DW_CFA_nop
409 padding byte, or END if there is no padding. Return null otherwise.
410 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
413 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
414 unsigned int *set_loc_count)
420 if (*buf == DW_CFA_nop)
424 if (*buf == DW_CFA_set_loc)
426 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
433 /* Convert absolute encoding ENCODING into PC-relative form.
434 SIZE is the size of a pointer. */
437 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
439 if ((encoding & 0x7f) == DW_EH_PE_absptr)
443 encoding |= DW_EH_PE_sdata2;
446 encoding |= DW_EH_PE_sdata4;
449 encoding |= DW_EH_PE_sdata8;
452 return encoding | DW_EH_PE_pcrel;
455 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
456 information in the section's sec_info field on success. COOKIE
457 describes the relocations in SEC. */
460 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
461 asection *sec, struct elf_reloc_cookie *cookie)
463 #define REQUIRE(COND) \
466 goto free_no_table; \
469 bfd_byte *ehbuf = NULL, *buf, *end;
471 struct eh_cie_fde *this_inf;
472 unsigned int hdr_length, hdr_id;
473 unsigned int cie_count;
474 struct cie *cie, *local_cies = NULL;
475 struct elf_link_hash_table *htab;
476 struct eh_frame_hdr_info *hdr_info;
477 struct eh_frame_sec_info *sec_info = NULL;
478 unsigned int ptr_size;
479 unsigned int num_cies;
480 unsigned int num_entries;
481 elf_gc_mark_hook_fn gc_mark_hook;
483 htab = elf_hash_table (info);
484 hdr_info = &htab->eh_info;
487 || sec->sec_info_type != SEC_INFO_TYPE_NONE)
489 /* This file does not contain .eh_frame information. */
493 if (bfd_is_abs_section (sec->output_section))
495 /* At least one of the sections is being discarded from the
496 link, so we should just ignore them. */
500 /* Read the frame unwind information from abfd. */
502 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
505 && bfd_get_32 (abfd, ehbuf) == 0
506 && cookie->rel == cookie->relend)
508 /* Empty .eh_frame section. */
513 /* If .eh_frame section size doesn't fit into int, we cannot handle
514 it (it would need to use 64-bit .eh_frame format anyway). */
515 REQUIRE (sec->size == (unsigned int) sec->size);
517 ptr_size = (get_elf_backend_data (abfd)
518 ->elf_backend_eh_frame_address_size (abfd, sec));
519 REQUIRE (ptr_size != 0);
521 /* Go through the section contents and work out how many FDEs and
524 end = ehbuf + sec->size;
531 /* Read the length of the entry. */
532 REQUIRE (skip_bytes (&buf, end, 4));
533 hdr_length = bfd_get_32 (abfd, buf - 4);
535 /* 64-bit .eh_frame is not supported. */
536 REQUIRE (hdr_length != 0xffffffff);
540 REQUIRE (skip_bytes (&buf, end, 4));
541 hdr_id = bfd_get_32 (abfd, buf - 4);
545 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
548 sec_info = (struct eh_frame_sec_info *)
549 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
550 + (num_entries - 1) * sizeof (struct eh_cie_fde));
553 /* We need to have a "struct cie" for each CIE in this section. */
554 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
555 REQUIRE (local_cies);
557 /* FIXME: octets_per_byte. */
558 #define ENSURE_NO_RELOCS(buf) \
559 while (cookie->rel < cookie->relend \
560 && (cookie->rel->r_offset \
561 < (bfd_size_type) ((buf) - ehbuf))) \
563 REQUIRE (cookie->rel->r_info == 0); \
567 /* FIXME: octets_per_byte. */
568 #define SKIP_RELOCS(buf) \
569 while (cookie->rel < cookie->relend \
570 && (cookie->rel->r_offset \
571 < (bfd_size_type) ((buf) - ehbuf))) \
574 /* FIXME: octets_per_byte. */
575 #define GET_RELOC(buf) \
576 ((cookie->rel < cookie->relend \
577 && (cookie->rel->r_offset \
578 == (bfd_size_type) ((buf) - ehbuf))) \
579 ? cookie->rel : NULL)
583 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
584 while ((bfd_size_type) (buf - ehbuf) != sec->size)
587 bfd_byte *start, *insns, *insns_end;
588 bfd_size_type length;
589 unsigned int set_loc_count;
591 this_inf = sec_info->entry + sec_info->count;
594 /* Read the length of the entry. */
595 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
596 hdr_length = bfd_get_32 (abfd, buf - 4);
598 /* The CIE/FDE must be fully contained in this input section. */
599 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
600 end = buf + hdr_length;
602 this_inf->offset = last_fde - ehbuf;
603 this_inf->size = 4 + hdr_length;
604 this_inf->reloc_index = cookie->rel - cookie->rels;
608 /* A zero-length CIE should only be found at the end of
610 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
611 ENSURE_NO_RELOCS (buf);
616 REQUIRE (skip_bytes (&buf, end, 4));
617 hdr_id = bfd_get_32 (abfd, buf - 4);
621 unsigned int initial_insn_length;
626 /* Point CIE to one of the section-local cie structures. */
627 cie = local_cies + cie_count++;
629 cie->cie_inf = this_inf;
630 cie->length = hdr_length;
632 REQUIRE (read_byte (&buf, end, &cie->version));
634 /* Cannot handle unknown versions. */
635 REQUIRE (cie->version == 1
637 || cie->version == 4);
638 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
640 strcpy (cie->augmentation, (char *) buf);
641 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
642 ENSURE_NO_RELOCS (buf);
643 if (buf[0] == 'e' && buf[1] == 'h')
645 /* GCC < 3.0 .eh_frame CIE */
646 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
647 is private to each CIE, so we don't need it for anything.
649 REQUIRE (skip_bytes (&buf, end, ptr_size));
652 if (cie->version >= 4)
654 REQUIRE (buf + 1 < end);
655 REQUIRE (buf[0] == ptr_size);
656 REQUIRE (buf[1] == 0);
659 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
660 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
661 if (cie->version == 1)
664 cie->ra_column = *buf++;
667 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
668 ENSURE_NO_RELOCS (buf);
669 cie->lsda_encoding = DW_EH_PE_omit;
670 cie->fde_encoding = DW_EH_PE_omit;
671 cie->per_encoding = DW_EH_PE_omit;
672 aug = cie->augmentation;
673 if (aug[0] != 'e' || aug[1] != 'h')
678 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
679 ENSURE_NO_RELOCS (buf);
686 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
687 ENSURE_NO_RELOCS (buf);
688 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
691 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
692 ENSURE_NO_RELOCS (buf);
693 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
701 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
702 per_width = get_DW_EH_PE_width (cie->per_encoding,
705 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
707 length = -(buf - ehbuf) & (per_width - 1);
708 REQUIRE (skip_bytes (&buf, end, length));
710 this_inf->u.cie.personality_offset = buf - start;
711 ENSURE_NO_RELOCS (buf);
712 /* Ensure we have a reloc here. */
713 REQUIRE (GET_RELOC (buf));
714 cie->personality.reloc_index
715 = cookie->rel - cookie->rels;
716 /* Cope with MIPS-style composite relocations. */
719 while (GET_RELOC (buf) != NULL);
720 REQUIRE (skip_bytes (&buf, end, per_width));
724 /* Unrecognized augmentation. Better bail out. */
729 /* For shared libraries, try to get rid of as many RELATIVE relocs
732 && !info->relocatable
733 && (get_elf_backend_data (abfd)
734 ->elf_backend_can_make_relative_eh_frame
737 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
738 this_inf->make_relative = 1;
739 /* If the CIE doesn't already have an 'R' entry, it's fairly
740 easy to add one, provided that there's no aligned data
741 after the augmentation string. */
742 else if (cie->fde_encoding == DW_EH_PE_omit
743 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
745 if (*cie->augmentation == 0)
746 this_inf->add_augmentation_size = 1;
747 this_inf->u.cie.add_fde_encoding = 1;
748 this_inf->make_relative = 1;
751 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
752 cie->can_make_lsda_relative = 1;
755 /* If FDE encoding was not specified, it defaults to
757 if (cie->fde_encoding == DW_EH_PE_omit)
758 cie->fde_encoding = DW_EH_PE_absptr;
760 initial_insn_length = end - buf;
761 cie->initial_insn_length = initial_insn_length;
762 memcpy (cie->initial_instructions, buf,
763 initial_insn_length <= sizeof (cie->initial_instructions)
764 ? initial_insn_length : sizeof (cie->initial_instructions));
766 buf += initial_insn_length;
767 ENSURE_NO_RELOCS (buf);
769 if (!info->relocatable)
771 /* Keep info for merging cies. */
772 this_inf->u.cie.u.full_cie = cie;
773 this_inf->u.cie.per_encoding_relative
774 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
779 /* Find the corresponding CIE. */
780 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
781 for (cie = local_cies; cie < local_cies + cie_count; cie++)
782 if (cie_offset == cie->cie_inf->offset)
785 /* Ensure this FDE references one of the CIEs in this input
787 REQUIRE (cie != local_cies + cie_count);
788 this_inf->u.fde.cie_inf = cie->cie_inf;
789 this_inf->make_relative = cie->cie_inf->make_relative;
790 this_inf->add_augmentation_size
791 = cie->cie_inf->add_augmentation_size;
793 ENSURE_NO_RELOCS (buf);
794 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
798 REQUIRE (GET_RELOC (buf));
800 /* Chain together the FDEs for each section. */
801 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
802 /* RSEC will be NULL if FDE was cleared out as it was belonging to
803 a discarded SHT_GROUP. */
806 REQUIRE (rsec->owner == abfd);
807 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
808 elf_fde_list (rsec) = this_inf;
812 /* Skip the initial location and address range. */
814 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
815 REQUIRE (skip_bytes (&buf, end, 2 * length));
817 SKIP_RELOCS (buf - length);
818 if (!GET_RELOC (buf - length)
819 && read_value (abfd, buf - length, length, FALSE) == 0)
821 (*info->callbacks->minfo)
822 (_("discarding zero address range FDE in %B(%A).\n"),
824 this_inf->u.fde.cie_inf = NULL;
827 /* Skip the augmentation size, if present. */
828 if (cie->augmentation[0] == 'z')
829 REQUIRE (read_uleb128 (&buf, end, &length));
833 /* Of the supported augmentation characters above, only 'L'
834 adds augmentation data to the FDE. This code would need to
835 be adjusted if any future augmentations do the same thing. */
836 if (cie->lsda_encoding != DW_EH_PE_omit)
839 if (cie->can_make_lsda_relative && GET_RELOC (buf))
840 cie->cie_inf->u.cie.make_lsda_relative = 1;
841 this_inf->lsda_offset = buf - start;
842 /* If there's no 'z' augmentation, we don't know where the
843 CFA insns begin. Assume no padding. */
844 if (cie->augmentation[0] != 'z')
848 /* Skip over the augmentation data. */
849 REQUIRE (skip_bytes (&buf, end, length));
852 buf = last_fde + 4 + hdr_length;
854 /* For NULL RSEC (cleared FDE belonging to a discarded section)
855 the relocations are commonly cleared. We do not sanity check if
856 all these relocations are cleared as (1) relocations to
857 .gcc_except_table will remain uncleared (they will get dropped
858 with the drop of this unused FDE) and (2) BFD already safely drops
859 relocations of any type to .eh_frame by
860 elf_section_ignore_discarded_relocs.
861 TODO: The .gcc_except_table entries should be also filtered as
862 .eh_frame entries; or GCC could rather use COMDAT for them. */
866 /* Try to interpret the CFA instructions and find the first
867 padding nop. Shrink this_inf's size so that it doesn't
868 include the padding. */
869 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
871 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
872 /* If we don't understand the CFA instructions, we can't know
873 what needs to be adjusted there. */
874 if (insns_end == NULL
875 /* For the time being we don't support DW_CFA_set_loc in
877 || (set_loc_count && this_inf->cie))
879 this_inf->size -= end - insns_end;
880 if (insns_end != end && this_inf->cie)
882 cie->initial_insn_length -= end - insns_end;
883 cie->length -= end - insns_end;
886 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
887 || this_inf->make_relative))
892 this_inf->set_loc = (unsigned int *)
893 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
894 REQUIRE (this_inf->set_loc);
895 this_inf->set_loc[0] = set_loc_count;
900 if (*p == DW_CFA_set_loc)
901 this_inf->set_loc[++cnt] = p + 1 - start;
902 REQUIRE (skip_cfa_op (&p, end, length));
906 this_inf->removed = 1;
907 this_inf->fde_encoding = cie->fde_encoding;
908 this_inf->lsda_encoding = cie->lsda_encoding;
911 BFD_ASSERT (sec_info->count == num_entries);
912 BFD_ASSERT (cie_count == num_cies);
914 elf_section_data (sec)->sec_info = sec_info;
915 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
916 if (!info->relocatable)
918 /* Keep info for merging cies. */
919 sec_info->cies = local_cies;
925 (*info->callbacks->einfo)
926 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
928 hdr_info->table = FALSE;
939 /* Mark all relocations against CIE or FDE ENT, which occurs in
940 .eh_frame section SEC. COOKIE describes the relocations in SEC;
941 its "rel" field can be changed freely. */
944 mark_entry (struct bfd_link_info *info, asection *sec,
945 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
946 struct elf_reloc_cookie *cookie)
948 /* FIXME: octets_per_byte. */
949 for (cookie->rel = cookie->rels + ent->reloc_index;
950 cookie->rel < cookie->relend
951 && cookie->rel->r_offset < ent->offset + ent->size;
953 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
959 /* Mark all the relocations against FDEs that relate to code in input
960 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
961 relocations are described by COOKIE. */
964 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
965 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
966 struct elf_reloc_cookie *cookie)
968 struct eh_cie_fde *fde, *cie;
970 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
972 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
975 /* At this stage, all cie_inf fields point to local CIEs, so we
976 can use the same cookie to refer to them. */
977 cie = fde->u.fde.cie_inf;
978 if (cie != NULL && !cie->u.cie.gc_mark)
980 cie->u.cie.gc_mark = 1;
981 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
988 /* Input section SEC of ABFD is an .eh_frame section that contains the
989 CIE described by CIE_INF. Return a version of CIE_INF that is going
990 to be kept in the output, adding CIE_INF to the output if necessary.
992 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
993 relocations in REL. */
995 static struct eh_cie_fde *
996 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
997 struct eh_frame_hdr_info *hdr_info,
998 struct elf_reloc_cookie *cookie,
999 struct eh_cie_fde *cie_inf)
1001 unsigned long r_symndx;
1002 struct cie *cie, *new_cie;
1003 Elf_Internal_Rela *rel;
1006 /* Use CIE_INF if we have already decided to keep it. */
1007 if (!cie_inf->removed)
1010 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1011 if (cie_inf->u.cie.merged)
1012 return cie_inf->u.cie.u.merged_with;
1014 cie = cie_inf->u.cie.u.full_cie;
1016 /* Assume we will need to keep CIE_INF. */
1017 cie_inf->removed = 0;
1018 cie_inf->u.cie.u.sec = sec;
1020 /* If we are not merging CIEs, use CIE_INF. */
1024 if (cie->per_encoding != DW_EH_PE_omit)
1026 bfd_boolean per_binds_local;
1028 /* Work out the address of personality routine, or at least
1029 enough info that we could calculate the address had we made a
1030 final section layout. The symbol on the reloc is enough,
1031 either the hash for a global, or (bfd id, index) pair for a
1032 local. The assumption here is that no one uses addends on
1034 rel = cookie->rels + cie->personality.reloc_index;
1035 memset (&cie->personality, 0, sizeof (cie->personality));
1037 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1038 r_symndx = ELF64_R_SYM (rel->r_info);
1041 r_symndx = ELF32_R_SYM (rel->r_info);
1042 if (r_symndx >= cookie->locsymcount
1043 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1045 struct elf_link_hash_entry *h;
1047 r_symndx -= cookie->extsymoff;
1048 h = cookie->sym_hashes[r_symndx];
1050 while (h->root.type == bfd_link_hash_indirect
1051 || h->root.type == bfd_link_hash_warning)
1052 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1054 cie->personality.h = h;
1055 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1059 Elf_Internal_Sym *sym;
1062 sym = &cookie->locsyms[r_symndx];
1063 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1064 if (sym_sec == NULL)
1067 if (sym_sec->kept_section != NULL)
1068 sym_sec = sym_sec->kept_section;
1069 if (sym_sec->output_section == NULL)
1072 cie->local_personality = 1;
1073 cie->personality.sym.bfd_id = abfd->id;
1074 cie->personality.sym.index = r_symndx;
1075 per_binds_local = TRUE;
1080 && !info->relocatable
1081 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1082 && (get_elf_backend_data (abfd)
1083 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1085 cie_inf->u.cie.make_per_encoding_relative = 1;
1086 cie_inf->u.cie.per_encoding_relative = 1;
1090 /* See if we can merge this CIE with an earlier one. */
1091 cie_compute_hash (cie);
1092 if (hdr_info->cies == NULL)
1094 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1095 if (hdr_info->cies == NULL)
1098 loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1102 new_cie = (struct cie *) *loc;
1103 if (new_cie == NULL)
1105 /* Keep CIE_INF and record it in the hash table. */
1106 new_cie = (struct cie *) malloc (sizeof (struct cie));
1107 if (new_cie == NULL)
1110 memcpy (new_cie, cie, sizeof (struct cie));
1115 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1116 cie_inf->removed = 1;
1117 cie_inf->u.cie.merged = 1;
1118 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1119 if (cie_inf->u.cie.make_lsda_relative)
1120 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1122 return new_cie->cie_inf;
1125 /* This function is called for each input file before the .eh_frame
1126 section is relocated. It discards duplicate CIEs and FDEs for discarded
1127 functions. The function returns TRUE iff any entries have been
1131 _bfd_elf_discard_section_eh_frame
1132 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1133 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1134 struct elf_reloc_cookie *cookie)
1136 struct eh_cie_fde *ent;
1137 struct eh_frame_sec_info *sec_info;
1138 struct eh_frame_hdr_info *hdr_info;
1139 unsigned int ptr_size, offset;
1141 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1144 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1145 if (sec_info == NULL)
1148 ptr_size = (get_elf_backend_data (sec->owner)
1149 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1151 hdr_info = &elf_hash_table (info)->eh_info;
1152 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1154 /* There should only be one zero terminator, on the last input
1155 file supplying .eh_frame (crtend.o). Remove any others. */
1156 ent->removed = sec->map_head.s != NULL;
1157 else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1160 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1163 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1165 = read_value (abfd, sec->contents + ent->offset + 8 + width,
1166 width, get_DW_EH_PE_signed (ent->fde_encoding));
1171 cookie->rel = cookie->rels + ent->reloc_index;
1172 /* FIXME: octets_per_byte. */
1173 BFD_ASSERT (cookie->rel < cookie->relend
1174 && cookie->rel->r_offset == ent->offset + 8);
1175 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1180 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1181 && ent->make_relative == 0)
1182 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1184 /* If a shared library uses absolute pointers
1185 which we cannot turn into PC relative,
1186 don't create the binary search table,
1187 since it is affected by runtime relocations. */
1188 hdr_info->table = FALSE;
1189 (*info->callbacks->einfo)
1190 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1191 " table being created.\n"), abfd, sec);
1194 hdr_info->fde_count++;
1195 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1196 cookie, ent->u.fde.cie_inf);
1202 free (sec_info->cies);
1203 sec_info->cies = NULL;
1207 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1210 ent->new_offset = offset;
1211 offset += size_of_output_cie_fde (ent, ptr_size);
1214 sec->rawsize = sec->size;
1216 return offset != sec->rawsize;
1219 /* This function is called for .eh_frame_hdr section after
1220 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1221 input sections. It finalizes the size of .eh_frame_hdr section. */
1224 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1226 struct elf_link_hash_table *htab;
1227 struct eh_frame_hdr_info *hdr_info;
1230 htab = elf_hash_table (info);
1231 hdr_info = &htab->eh_info;
1233 if (hdr_info->cies != NULL)
1235 htab_delete (hdr_info->cies);
1236 hdr_info->cies = NULL;
1239 sec = hdr_info->hdr_sec;
1243 sec->size = EH_FRAME_HDR_SIZE;
1244 if (hdr_info->table)
1245 sec->size += 4 + hdr_info->fde_count * 8;
1247 elf_eh_frame_hdr (abfd) = sec;
1251 /* Return true if there is at least one non-empty .eh_frame section in
1252 input files. Can only be called after ld has mapped input to
1253 output sections, and before sections are stripped. */
1255 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1257 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1262 /* Count only sections which have at least a single CIE or FDE.
1263 There cannot be any CIE or FDE <= 8 bytes. */
1264 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1271 /* This function is called from size_dynamic_sections.
1272 It needs to decide whether .eh_frame_hdr should be output or not,
1273 because when the dynamic symbol table has been sized it is too late
1274 to strip sections. */
1277 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1279 struct elf_link_hash_table *htab;
1280 struct eh_frame_hdr_info *hdr_info;
1282 htab = elf_hash_table (info);
1283 hdr_info = &htab->eh_info;
1284 if (hdr_info->hdr_sec == NULL)
1287 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1288 || !info->eh_frame_hdr
1289 || !_bfd_elf_eh_frame_present (info))
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);
1587 if (info->relocatable)
1590 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1591 value = read_value (abfd, buf, width,
1592 get_DW_EH_PE_signed (ent->fde_encoding));
1596 switch (ent->fde_encoding & 0x70)
1598 case DW_EH_PE_textrel:
1599 BFD_ASSERT (hdr_info == NULL);
1601 case DW_EH_PE_datarel:
1603 switch (abfd->arch_info->arch)
1606 BFD_ASSERT (elf_gp (abfd) != 0);
1607 address += elf_gp (abfd);
1610 (*info->callbacks->einfo)
1611 (_("%P: DW_EH_PE_datarel unspecified"
1612 " for this architecture.\n"));
1616 BFD_ASSERT (htab->hgot != NULL
1617 && ((htab->hgot->root.type
1618 == bfd_link_hash_defined)
1619 || (htab->hgot->root.type
1620 == bfd_link_hash_defweak)));
1622 += (htab->hgot->root.u.def.value
1623 + htab->hgot->root.u.def.section->output_offset
1624 + (htab->hgot->root.u.def.section->output_section
1630 case DW_EH_PE_pcrel:
1631 value += (bfd_vma) ent->offset - ent->new_offset;
1632 address += (sec->output_section->vma
1633 + sec->output_offset
1637 if (ent->make_relative)
1638 value -= (sec->output_section->vma
1639 + sec->output_offset
1640 + ent->new_offset + 8);
1641 write_value (abfd, buf, value, width);
1648 /* The address calculation may overflow, giving us a
1649 value greater than 4G on a 32-bit target when
1650 dwarf_vma is 64-bit. */
1651 if (sizeof (address) > 4 && ptr_size == 4)
1652 address &= 0xffffffff;
1653 hdr_info->array[hdr_info->array_count].initial_loc = address;
1654 hdr_info->array[hdr_info->array_count].range
1655 = read_value (abfd, buf + width, width, FALSE);
1656 hdr_info->array[hdr_info->array_count++].fde
1657 = (sec->output_section->vma
1658 + sec->output_offset
1662 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1663 || cie->u.cie.make_lsda_relative)
1665 buf += ent->lsda_offset;
1666 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1667 value = read_value (abfd, buf, width,
1668 get_DW_EH_PE_signed (ent->lsda_encoding));
1671 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1672 value += (bfd_vma) ent->offset - ent->new_offset;
1673 else if (cie->u.cie.make_lsda_relative)
1674 value -= (sec->output_section->vma
1675 + sec->output_offset
1676 + ent->new_offset + 8 + ent->lsda_offset);
1677 write_value (abfd, buf, value, width);
1680 else if (ent->add_augmentation_size)
1682 /* Skip the PC and length and insert a zero byte for the
1683 augmentation size. */
1685 memmove (buf + 1, buf, end - buf);
1691 /* Adjust DW_CFA_set_loc. */
1695 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1696 new_offset = ent->new_offset + 8
1697 + extra_augmentation_string_bytes (ent)
1698 + extra_augmentation_data_bytes (ent);
1700 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1702 buf = start + ent->set_loc[cnt];
1704 value = read_value (abfd, buf, width,
1705 get_DW_EH_PE_signed (ent->fde_encoding));
1709 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1710 value += (bfd_vma) ent->offset + 8 - new_offset;
1711 if (ent->make_relative)
1712 value -= (sec->output_section->vma
1713 + sec->output_offset
1714 + new_offset + ent->set_loc[cnt]);
1715 write_value (abfd, buf, value, width);
1721 /* We don't align the section to its section alignment since the
1722 runtime library only expects all CIE/FDE records aligned at
1723 the pointer size. _bfd_elf_discard_section_eh_frame should
1724 have padded CIE/FDE records to multiple of pointer size with
1725 size_of_output_cie_fde. */
1726 if ((sec->size % ptr_size) != 0)
1729 /* FIXME: octets_per_byte. */
1730 return bfd_set_section_contents (abfd, sec->output_section,
1731 contents, (file_ptr) sec->output_offset,
1735 /* Helper function used to sort .eh_frame_hdr search table by increasing
1736 VMA of FDE initial location. */
1739 vma_compare (const void *a, const void *b)
1741 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1742 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1743 if (p->initial_loc > q->initial_loc)
1745 if (p->initial_loc < q->initial_loc)
1747 if (p->range > q->range)
1749 if (p->range < q->range)
1754 /* Write out .eh_frame_hdr section. This must be called after
1755 _bfd_elf_write_section_eh_frame has been called on all input
1757 .eh_frame_hdr format:
1758 ubyte version (currently 1)
1759 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1761 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1762 number (or DW_EH_PE_omit if there is no
1763 binary search table computed))
1764 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1765 or DW_EH_PE_omit if not present.
1766 DW_EH_PE_datarel is using address of
1767 .eh_frame_hdr section start as base)
1768 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1769 optionally followed by:
1770 [encoded] fde_count (total number of FDEs in .eh_frame section)
1771 fde_count x [encoded] initial_loc, fde
1772 (array of encoded pairs containing
1773 FDE initial_location field and FDE address,
1774 sorted by increasing initial_loc). */
1777 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1779 struct elf_link_hash_table *htab;
1780 struct eh_frame_hdr_info *hdr_info;
1782 bfd_boolean retval = TRUE;
1784 htab = elf_hash_table (info);
1785 hdr_info = &htab->eh_info;
1786 sec = hdr_info->hdr_sec;
1788 if (info->eh_frame_hdr && sec != NULL)
1791 asection *eh_frame_sec;
1793 bfd_vma encoded_eh_frame;
1795 size = EH_FRAME_HDR_SIZE;
1796 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1797 size += 4 + hdr_info->fde_count * 8;
1798 contents = (bfd_byte *) bfd_malloc (size);
1799 if (contents == NULL)
1802 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1803 if (eh_frame_sec == NULL)
1809 memset (contents, 0, EH_FRAME_HDR_SIZE);
1812 /* .eh_frame offset. */
1813 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1814 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
1816 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1818 /* FDE count encoding. */
1819 contents[2] = DW_EH_PE_udata4;
1820 /* Search table encoding. */
1821 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
1825 contents[2] = DW_EH_PE_omit;
1826 contents[3] = DW_EH_PE_omit;
1828 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1830 if (contents[2] != DW_EH_PE_omit)
1834 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1835 qsort (hdr_info->array, hdr_info->fde_count,
1836 sizeof (*hdr_info->array), vma_compare);
1837 for (i = 0; i < hdr_info->fde_count; i++)
1841 val = hdr_info->array[i].initial_loc - sec->output_section->vma;
1842 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1843 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
1844 && (hdr_info->array[i].initial_loc
1845 != sec->output_section->vma + val))
1846 (*info->callbacks->einfo)
1847 (_("%X%P: .eh_frame_hdr table[%u] PC overflow.\n"), i);
1848 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1850 val = hdr_info->array[i].fde - sec->output_section->vma;
1851 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1852 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
1853 && (hdr_info->array[i].fde
1854 != sec->output_section->vma + val))
1855 (*info->callbacks->einfo)
1856 (_("%X%P: .eh_frame_hdr table[%u] FDE overflow.\n"), i);
1857 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1860 && (hdr_info->array[i].initial_loc
1861 < (hdr_info->array[i - 1].initial_loc
1862 + hdr_info->array[i - 1].range)))
1863 (*info->callbacks->einfo)
1864 (_("%X%P: .eh_frame_hdr table[%u] FDE at %V overlaps "
1865 "table[%u] FDE at %V.\n"),
1866 i - 1, hdr_info->array[i - 1].fde,
1867 i, hdr_info->array[i].fde);
1871 /* FIXME: octets_per_byte. */
1872 if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1873 (file_ptr) sec->output_offset,
1878 if (hdr_info->array != NULL)
1879 free (hdr_info->array);
1883 /* Return the width of FDE addresses. This is the default implementation. */
1886 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1888 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1891 /* Decide whether we can use a PC-relative encoding within the given
1892 EH frame section. This is the default implementation. */
1895 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1896 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1897 asection *eh_frame_section ATTRIBUTE_UNUSED)
1902 /* Select an encoding for the given address. Preference is given to
1903 PC-relative addressing modes. */
1906 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1907 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1908 asection *osec, bfd_vma offset,
1909 asection *loc_sec, bfd_vma loc_offset,
1912 *encoded = osec->vma + offset -
1913 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1914 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;