1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2017 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. */
315 size_of_output_cie_fde (struct eh_cie_fde *entry)
319 if (entry->size == 4)
322 + extra_augmentation_string_bytes (entry)
323 + extra_augmentation_data_bytes (entry));
326 /* Return the offset of the FDE or CIE after ENT. */
329 next_cie_fde_offset (struct eh_cie_fde *ent,
330 struct eh_cie_fde *last,
336 return ent->new_offset;
341 /* Assume that the bytes between *ITER and END are CFA instructions.
342 Try to move *ITER past the first instruction and return true on
343 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
346 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
351 if (!read_byte (iter, end, &op))
354 switch (op & 0xc0 ? op & 0xc0 : op)
357 case DW_CFA_advance_loc:
359 case DW_CFA_remember_state:
360 case DW_CFA_restore_state:
361 case DW_CFA_GNU_window_save:
366 case DW_CFA_restore_extended:
367 case DW_CFA_undefined:
368 case DW_CFA_same_value:
369 case DW_CFA_def_cfa_register:
370 case DW_CFA_def_cfa_offset:
371 case DW_CFA_def_cfa_offset_sf:
372 case DW_CFA_GNU_args_size:
373 /* One leb128 argument. */
374 return skip_leb128 (iter, end);
376 case DW_CFA_val_offset:
377 case DW_CFA_val_offset_sf:
378 case DW_CFA_offset_extended:
379 case DW_CFA_register:
381 case DW_CFA_offset_extended_sf:
382 case DW_CFA_GNU_negative_offset_extended:
383 case DW_CFA_def_cfa_sf:
384 /* Two leb128 arguments. */
385 return (skip_leb128 (iter, end)
386 && skip_leb128 (iter, end));
388 case DW_CFA_def_cfa_expression:
389 /* A variable-length argument. */
390 return (read_uleb128 (iter, end, &length)
391 && skip_bytes (iter, end, length));
393 case DW_CFA_expression:
394 case DW_CFA_val_expression:
395 /* A leb128 followed by a variable-length argument. */
396 return (skip_leb128 (iter, end)
397 && read_uleb128 (iter, end, &length)
398 && skip_bytes (iter, end, length));
401 return skip_bytes (iter, end, encoded_ptr_width);
403 case DW_CFA_advance_loc1:
404 return skip_bytes (iter, end, 1);
406 case DW_CFA_advance_loc2:
407 return skip_bytes (iter, end, 2);
409 case DW_CFA_advance_loc4:
410 return skip_bytes (iter, end, 4);
412 case DW_CFA_MIPS_advance_loc8:
413 return skip_bytes (iter, end, 8);
420 /* Try to interpret the bytes between BUF and END as CFA instructions.
421 If every byte makes sense, return a pointer to the first DW_CFA_nop
422 padding byte, or END if there is no padding. Return null otherwise.
423 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
426 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
427 unsigned int *set_loc_count)
433 if (*buf == DW_CFA_nop)
437 if (*buf == DW_CFA_set_loc)
439 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
446 /* Convert absolute encoding ENCODING into PC-relative form.
447 SIZE is the size of a pointer. */
450 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
452 if ((encoding & 0x7f) == DW_EH_PE_absptr)
456 encoding |= DW_EH_PE_sdata2;
459 encoding |= DW_EH_PE_sdata4;
462 encoding |= DW_EH_PE_sdata8;
465 return encoding | DW_EH_PE_pcrel;
468 /* Examine each .eh_frame_entry section and discard those
469 those that are marked SEC_EXCLUDE. */
472 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
475 for (i = 0; i < hdr_info->array_count; i++)
477 if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
480 for (j = i + 1; j < hdr_info->array_count; j++)
481 hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
483 hdr_info->array_count--;
484 hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
490 /* Add a .eh_frame_entry section. */
493 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
496 if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
498 if (hdr_info->u.compact.allocated_entries == 0)
500 hdr_info->frame_hdr_is_compact = TRUE;
501 hdr_info->u.compact.allocated_entries = 2;
502 hdr_info->u.compact.entries =
503 bfd_malloc (hdr_info->u.compact.allocated_entries
504 * sizeof (hdr_info->u.compact.entries[0]));
508 hdr_info->u.compact.allocated_entries *= 2;
509 hdr_info->u.compact.entries =
510 bfd_realloc (hdr_info->u.compact.entries,
511 hdr_info->u.compact.allocated_entries
512 * sizeof (hdr_info->u.compact.entries[0]));
515 BFD_ASSERT (hdr_info->u.compact.entries);
518 hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
521 /* Parse a .eh_frame_entry section. Figure out which text section it
525 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
526 asection *sec, struct elf_reloc_cookie *cookie)
528 struct elf_link_hash_table *htab;
529 struct eh_frame_hdr_info *hdr_info;
530 unsigned long r_symndx;
533 htab = elf_hash_table (info);
534 hdr_info = &htab->eh_info;
537 || sec->sec_info_type != SEC_INFO_TYPE_NONE)
542 if (sec->output_section && bfd_is_abs_section (sec->output_section))
544 /* At least one of the sections is being discarded from the
545 link, so we should just ignore them. */
549 if (cookie->rel == cookie->relend)
552 /* The first relocation is the function start. */
553 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
554 if (r_symndx == STN_UNDEF)
557 text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
559 if (text_sec == NULL)
562 elf_section_eh_frame_entry (text_sec) = sec;
563 if (text_sec->output_section
564 && bfd_is_abs_section (text_sec->output_section))
565 sec->flags |= SEC_EXCLUDE;
567 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
568 elf_section_data (sec)->sec_info = text_sec;
569 bfd_elf_record_eh_frame_entry (hdr_info, sec);
573 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
574 information in the section's sec_info field on success. COOKIE
575 describes the relocations in SEC. */
578 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
579 asection *sec, struct elf_reloc_cookie *cookie)
581 #define REQUIRE(COND) \
584 goto free_no_table; \
587 bfd_byte *ehbuf = NULL, *buf, *end;
589 struct eh_cie_fde *this_inf;
590 unsigned int hdr_length, hdr_id;
591 unsigned int cie_count;
592 struct cie *cie, *local_cies = NULL;
593 struct elf_link_hash_table *htab;
594 struct eh_frame_hdr_info *hdr_info;
595 struct eh_frame_sec_info *sec_info = NULL;
596 unsigned int ptr_size;
597 unsigned int num_cies;
598 unsigned int num_entries;
599 elf_gc_mark_hook_fn gc_mark_hook;
601 htab = elf_hash_table (info);
602 hdr_info = &htab->eh_info;
605 || sec->sec_info_type != SEC_INFO_TYPE_NONE)
607 /* This file does not contain .eh_frame information. */
611 if (bfd_is_abs_section (sec->output_section))
613 /* At least one of the sections is being discarded from the
614 link, so we should just ignore them. */
618 /* Read the frame unwind information from abfd. */
620 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
623 && bfd_get_32 (abfd, ehbuf) == 0
624 && cookie->rel == cookie->relend)
626 /* Empty .eh_frame section. */
631 /* If .eh_frame section size doesn't fit into int, we cannot handle
632 it (it would need to use 64-bit .eh_frame format anyway). */
633 REQUIRE (sec->size == (unsigned int) sec->size);
635 ptr_size = (get_elf_backend_data (abfd)
636 ->elf_backend_eh_frame_address_size (abfd, sec));
637 REQUIRE (ptr_size != 0);
639 /* Go through the section contents and work out how many FDEs and
642 end = ehbuf + sec->size;
649 /* Read the length of the entry. */
650 REQUIRE (skip_bytes (&buf, end, 4));
651 hdr_length = bfd_get_32 (abfd, buf - 4);
653 /* 64-bit .eh_frame is not supported. */
654 REQUIRE (hdr_length != 0xffffffff);
658 REQUIRE (skip_bytes (&buf, end, 4));
659 hdr_id = bfd_get_32 (abfd, buf - 4);
663 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
666 sec_info = (struct eh_frame_sec_info *)
667 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
668 + (num_entries - 1) * sizeof (struct eh_cie_fde));
671 /* We need to have a "struct cie" for each CIE in this section. */
672 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
673 REQUIRE (local_cies);
675 /* FIXME: octets_per_byte. */
676 #define ENSURE_NO_RELOCS(buf) \
677 while (cookie->rel < cookie->relend \
678 && (cookie->rel->r_offset \
679 < (bfd_size_type) ((buf) - ehbuf))) \
681 REQUIRE (cookie->rel->r_info == 0); \
685 /* FIXME: octets_per_byte. */
686 #define SKIP_RELOCS(buf) \
687 while (cookie->rel < cookie->relend \
688 && (cookie->rel->r_offset \
689 < (bfd_size_type) ((buf) - ehbuf))) \
692 /* FIXME: octets_per_byte. */
693 #define GET_RELOC(buf) \
694 ((cookie->rel < cookie->relend \
695 && (cookie->rel->r_offset \
696 == (bfd_size_type) ((buf) - ehbuf))) \
697 ? cookie->rel : NULL)
701 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
702 while ((bfd_size_type) (buf - ehbuf) != sec->size)
705 bfd_byte *start, *insns, *insns_end;
706 bfd_size_type length;
707 unsigned int set_loc_count;
709 this_inf = sec_info->entry + sec_info->count;
712 /* Read the length of the entry. */
713 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
714 hdr_length = bfd_get_32 (abfd, buf - 4);
716 /* The CIE/FDE must be fully contained in this input section. */
717 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
718 end = buf + hdr_length;
720 this_inf->offset = last_fde - ehbuf;
721 this_inf->size = 4 + hdr_length;
722 this_inf->reloc_index = cookie->rel - cookie->rels;
726 /* A zero-length CIE should only be found at the end of
728 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
729 ENSURE_NO_RELOCS (buf);
734 REQUIRE (skip_bytes (&buf, end, 4));
735 hdr_id = bfd_get_32 (abfd, buf - 4);
739 unsigned int initial_insn_length;
744 /* Point CIE to one of the section-local cie structures. */
745 cie = local_cies + cie_count++;
747 cie->cie_inf = this_inf;
748 cie->length = hdr_length;
750 REQUIRE (read_byte (&buf, end, &cie->version));
752 /* Cannot handle unknown versions. */
753 REQUIRE (cie->version == 1
755 || cie->version == 4);
756 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
758 strcpy (cie->augmentation, (char *) buf);
759 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
760 ENSURE_NO_RELOCS (buf);
761 if (buf[0] == 'e' && buf[1] == 'h')
763 /* GCC < 3.0 .eh_frame CIE */
764 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
765 is private to each CIE, so we don't need it for anything.
767 REQUIRE (skip_bytes (&buf, end, ptr_size));
770 if (cie->version >= 4)
772 REQUIRE (buf + 1 < end);
773 REQUIRE (buf[0] == ptr_size);
774 REQUIRE (buf[1] == 0);
777 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
778 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
779 if (cie->version == 1)
782 cie->ra_column = *buf++;
785 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
786 ENSURE_NO_RELOCS (buf);
787 cie->lsda_encoding = DW_EH_PE_omit;
788 cie->fde_encoding = DW_EH_PE_omit;
789 cie->per_encoding = DW_EH_PE_omit;
790 aug = cie->augmentation;
791 if (aug[0] != 'e' || aug[1] != 'h')
796 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
797 ENSURE_NO_RELOCS (buf);
804 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
805 ENSURE_NO_RELOCS (buf);
806 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
809 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
810 ENSURE_NO_RELOCS (buf);
811 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
819 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
820 per_width = get_DW_EH_PE_width (cie->per_encoding,
823 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
825 length = -(buf - ehbuf) & (per_width - 1);
826 REQUIRE (skip_bytes (&buf, end, length));
828 this_inf->u.cie.per_encoding_aligned8 = 1;
830 this_inf->u.cie.personality_offset = buf - start;
831 ENSURE_NO_RELOCS (buf);
832 /* Ensure we have a reloc here. */
833 REQUIRE (GET_RELOC (buf));
834 cie->personality.reloc_index
835 = cookie->rel - cookie->rels;
836 /* Cope with MIPS-style composite relocations. */
839 while (GET_RELOC (buf) != NULL);
840 REQUIRE (skip_bytes (&buf, end, per_width));
844 /* Unrecognized augmentation. Better bail out. */
849 /* For shared libraries, try to get rid of as many RELATIVE relocs
851 if (bfd_link_pic (info)
852 && (get_elf_backend_data (abfd)
853 ->elf_backend_can_make_relative_eh_frame
856 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
857 this_inf->make_relative = 1;
858 /* If the CIE doesn't already have an 'R' entry, it's fairly
859 easy to add one, provided that there's no aligned data
860 after the augmentation string. */
861 else if (cie->fde_encoding == DW_EH_PE_omit
862 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
864 if (*cie->augmentation == 0)
865 this_inf->add_augmentation_size = 1;
866 this_inf->u.cie.add_fde_encoding = 1;
867 this_inf->make_relative = 1;
870 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
871 cie->can_make_lsda_relative = 1;
874 /* If FDE encoding was not specified, it defaults to
876 if (cie->fde_encoding == DW_EH_PE_omit)
877 cie->fde_encoding = DW_EH_PE_absptr;
879 initial_insn_length = end - buf;
880 cie->initial_insn_length = initial_insn_length;
881 memcpy (cie->initial_instructions, buf,
882 initial_insn_length <= sizeof (cie->initial_instructions)
883 ? initial_insn_length : sizeof (cie->initial_instructions));
885 buf += initial_insn_length;
886 ENSURE_NO_RELOCS (buf);
888 if (!bfd_link_relocatable (info))
890 /* Keep info for merging cies. */
891 this_inf->u.cie.u.full_cie = cie;
892 this_inf->u.cie.per_encoding_relative
893 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
898 /* Find the corresponding CIE. */
899 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
900 for (cie = local_cies; cie < local_cies + cie_count; cie++)
901 if (cie_offset == cie->cie_inf->offset)
904 /* Ensure this FDE references one of the CIEs in this input
906 REQUIRE (cie != local_cies + cie_count);
907 this_inf->u.fde.cie_inf = cie->cie_inf;
908 this_inf->make_relative = cie->cie_inf->make_relative;
909 this_inf->add_augmentation_size
910 = cie->cie_inf->add_augmentation_size;
912 ENSURE_NO_RELOCS (buf);
913 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
917 REQUIRE (GET_RELOC (buf));
919 /* Chain together the FDEs for each section. */
920 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook,
922 /* RSEC will be NULL if FDE was cleared out as it was belonging to
923 a discarded SHT_GROUP. */
926 REQUIRE (rsec->owner == abfd);
927 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
928 elf_fde_list (rsec) = this_inf;
932 /* Skip the initial location and address range. */
934 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
935 REQUIRE (skip_bytes (&buf, end, 2 * length));
937 SKIP_RELOCS (buf - length);
938 if (!GET_RELOC (buf - length)
939 && read_value (abfd, buf - length, length, FALSE) == 0)
941 (*info->callbacks->minfo)
942 /* xgettext:c-format */
943 (_("discarding zero address range FDE in %B(%A).\n"),
945 this_inf->u.fde.cie_inf = NULL;
948 /* Skip the augmentation size, if present. */
949 if (cie->augmentation[0] == 'z')
950 REQUIRE (read_uleb128 (&buf, end, &length));
954 /* Of the supported augmentation characters above, only 'L'
955 adds augmentation data to the FDE. This code would need to
956 be adjusted if any future augmentations do the same thing. */
957 if (cie->lsda_encoding != DW_EH_PE_omit)
960 if (cie->can_make_lsda_relative && GET_RELOC (buf))
961 cie->cie_inf->u.cie.make_lsda_relative = 1;
962 this_inf->lsda_offset = buf - start;
963 /* If there's no 'z' augmentation, we don't know where the
964 CFA insns begin. Assume no padding. */
965 if (cie->augmentation[0] != 'z')
969 /* Skip over the augmentation data. */
970 REQUIRE (skip_bytes (&buf, end, length));
973 buf = last_fde + 4 + hdr_length;
975 /* For NULL RSEC (cleared FDE belonging to a discarded section)
976 the relocations are commonly cleared. We do not sanity check if
977 all these relocations are cleared as (1) relocations to
978 .gcc_except_table will remain uncleared (they will get dropped
979 with the drop of this unused FDE) and (2) BFD already safely drops
980 relocations of any type to .eh_frame by
981 elf_section_ignore_discarded_relocs.
982 TODO: The .gcc_except_table entries should be also filtered as
983 .eh_frame entries; or GCC could rather use COMDAT for them. */
987 /* Try to interpret the CFA instructions and find the first
988 padding nop. Shrink this_inf's size so that it doesn't
989 include the padding. */
990 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
992 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
993 /* If we don't understand the CFA instructions, we can't know
994 what needs to be adjusted there. */
995 if (insns_end == NULL
996 /* For the time being we don't support DW_CFA_set_loc in
998 || (set_loc_count && this_inf->cie))
1000 this_inf->size -= end - insns_end;
1001 if (insns_end != end && this_inf->cie)
1003 cie->initial_insn_length -= end - insns_end;
1004 cie->length -= end - insns_end;
1007 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
1008 || this_inf->make_relative))
1013 this_inf->set_loc = (unsigned int *)
1014 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
1015 REQUIRE (this_inf->set_loc);
1016 this_inf->set_loc[0] = set_loc_count;
1021 if (*p == DW_CFA_set_loc)
1022 this_inf->set_loc[++cnt] = p + 1 - start;
1023 REQUIRE (skip_cfa_op (&p, end, length));
1027 this_inf->removed = 1;
1028 this_inf->fde_encoding = cie->fde_encoding;
1029 this_inf->lsda_encoding = cie->lsda_encoding;
1032 BFD_ASSERT (sec_info->count == num_entries);
1033 BFD_ASSERT (cie_count == num_cies);
1035 elf_section_data (sec)->sec_info = sec_info;
1036 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1037 if (!bfd_link_relocatable (info))
1039 /* Keep info for merging cies. */
1040 sec_info->cies = local_cies;
1046 (*info->callbacks->einfo)
1047 /* xgettext:c-format */
1048 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1050 hdr_info->u.dwarf.table = FALSE;
1061 /* Order eh_frame_hdr entries by the VMA of their text section. */
1064 cmp_eh_frame_hdr (const void *a, const void *b)
1070 sec = *(asection *const *)a;
1071 sec = (asection *) elf_section_data (sec)->sec_info;
1072 text_a = sec->output_section->vma + sec->output_offset;
1073 sec = *(asection *const *)b;
1074 sec = (asection *) elf_section_data (sec)->sec_info;
1075 text_b = sec->output_section->vma + sec->output_offset;
1077 if (text_a < text_b)
1079 return text_a > text_b;
1083 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1084 referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1087 add_eh_frame_hdr_terminator (asection *sec,
1096 /* See if there is a gap (presumably a text section without unwind info)
1097 between these two entries. */
1098 text_sec = (asection *) elf_section_data (sec)->sec_info;
1099 end = text_sec->output_section->vma + text_sec->output_offset
1101 text_sec = (asection *) elf_section_data (next)->sec_info;
1102 next_start = text_sec->output_section->vma + text_sec->output_offset;
1103 if (end == next_start)
1107 /* Add space for a CANTUNWIND terminator. */
1109 sec->rawsize = sec->size;
1111 bfd_set_section_size (sec->owner, sec, sec->size + 8);
1114 /* Finish a pass over all .eh_frame_entry sections. */
1117 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1119 struct eh_frame_hdr_info *hdr_info;
1122 hdr_info = &elf_hash_table (info)->eh_info;
1124 if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1125 || hdr_info->array_count == 0)
1128 bfd_elf_discard_eh_frame_entry (hdr_info);
1130 qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1131 sizeof (asection *), cmp_eh_frame_hdr);
1133 for (i = 0; i < hdr_info->array_count - 1; i++)
1135 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1136 hdr_info->u.compact.entries[i + 1]);
1139 /* Add a CANTUNWIND terminator after the last entry. */
1140 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1144 /* Mark all relocations against CIE or FDE ENT, which occurs in
1145 .eh_frame section SEC. COOKIE describes the relocations in SEC;
1146 its "rel" field can be changed freely. */
1149 mark_entry (struct bfd_link_info *info, asection *sec,
1150 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1151 struct elf_reloc_cookie *cookie)
1153 /* FIXME: octets_per_byte. */
1154 for (cookie->rel = cookie->rels + ent->reloc_index;
1155 cookie->rel < cookie->relend
1156 && cookie->rel->r_offset < ent->offset + ent->size;
1158 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1164 /* Mark all the relocations against FDEs that relate to code in input
1165 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1166 relocations are described by COOKIE. */
1169 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1170 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1171 struct elf_reloc_cookie *cookie)
1173 struct eh_cie_fde *fde, *cie;
1175 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1177 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1180 /* At this stage, all cie_inf fields point to local CIEs, so we
1181 can use the same cookie to refer to them. */
1182 cie = fde->u.fde.cie_inf;
1183 if (cie != NULL && !cie->u.cie.gc_mark)
1185 cie->u.cie.gc_mark = 1;
1186 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1193 /* Input section SEC of ABFD is an .eh_frame section that contains the
1194 CIE described by CIE_INF. Return a version of CIE_INF that is going
1195 to be kept in the output, adding CIE_INF to the output if necessary.
1197 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1198 relocations in REL. */
1200 static struct eh_cie_fde *
1201 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1202 struct eh_frame_hdr_info *hdr_info,
1203 struct elf_reloc_cookie *cookie,
1204 struct eh_cie_fde *cie_inf)
1206 unsigned long r_symndx;
1207 struct cie *cie, *new_cie;
1208 Elf_Internal_Rela *rel;
1211 /* Use CIE_INF if we have already decided to keep it. */
1212 if (!cie_inf->removed)
1215 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1216 if (cie_inf->u.cie.merged)
1217 return cie_inf->u.cie.u.merged_with;
1219 cie = cie_inf->u.cie.u.full_cie;
1221 /* Assume we will need to keep CIE_INF. */
1222 cie_inf->removed = 0;
1223 cie_inf->u.cie.u.sec = sec;
1225 /* If we are not merging CIEs, use CIE_INF. */
1229 if (cie->per_encoding != DW_EH_PE_omit)
1231 bfd_boolean per_binds_local;
1233 /* Work out the address of personality routine, or at least
1234 enough info that we could calculate the address had we made a
1235 final section layout. The symbol on the reloc is enough,
1236 either the hash for a global, or (bfd id, index) pair for a
1237 local. The assumption here is that no one uses addends on
1239 rel = cookie->rels + cie->personality.reloc_index;
1240 memset (&cie->personality, 0, sizeof (cie->personality));
1242 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1243 r_symndx = ELF64_R_SYM (rel->r_info);
1246 r_symndx = ELF32_R_SYM (rel->r_info);
1247 if (r_symndx >= cookie->locsymcount
1248 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1250 struct elf_link_hash_entry *h;
1252 r_symndx -= cookie->extsymoff;
1253 h = cookie->sym_hashes[r_symndx];
1255 while (h->root.type == bfd_link_hash_indirect
1256 || h->root.type == bfd_link_hash_warning)
1257 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1259 cie->personality.h = h;
1260 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1264 Elf_Internal_Sym *sym;
1267 sym = &cookie->locsyms[r_symndx];
1268 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1269 if (sym_sec == NULL)
1272 if (sym_sec->kept_section != NULL)
1273 sym_sec = sym_sec->kept_section;
1274 if (sym_sec->output_section == NULL)
1277 cie->local_personality = 1;
1278 cie->personality.sym.bfd_id = abfd->id;
1279 cie->personality.sym.index = r_symndx;
1280 per_binds_local = TRUE;
1284 && bfd_link_pic (info)
1285 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1286 && (get_elf_backend_data (abfd)
1287 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1289 cie_inf->u.cie.make_per_encoding_relative = 1;
1290 cie_inf->u.cie.per_encoding_relative = 1;
1294 /* See if we can merge this CIE with an earlier one. */
1295 cie_compute_hash (cie);
1296 if (hdr_info->u.dwarf.cies == NULL)
1298 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1299 if (hdr_info->u.dwarf.cies == NULL)
1302 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1307 new_cie = (struct cie *) *loc;
1308 if (new_cie == NULL)
1310 /* Keep CIE_INF and record it in the hash table. */
1311 new_cie = (struct cie *) malloc (sizeof (struct cie));
1312 if (new_cie == NULL)
1315 memcpy (new_cie, cie, sizeof (struct cie));
1320 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1321 cie_inf->removed = 1;
1322 cie_inf->u.cie.merged = 1;
1323 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1324 if (cie_inf->u.cie.make_lsda_relative)
1325 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1327 return new_cie->cie_inf;
1330 /* This function is called for each input file before the .eh_frame
1331 section is relocated. It discards duplicate CIEs and FDEs for discarded
1332 functions. The function returns TRUE iff any entries have been
1336 _bfd_elf_discard_section_eh_frame
1337 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1338 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1339 struct elf_reloc_cookie *cookie)
1341 struct eh_cie_fde *ent;
1342 struct eh_frame_sec_info *sec_info;
1343 struct eh_frame_hdr_info *hdr_info;
1344 unsigned int ptr_size, offset, eh_alignment;
1346 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1349 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1350 if (sec_info == NULL)
1353 ptr_size = (get_elf_backend_data (sec->owner)
1354 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1356 hdr_info = &elf_hash_table (info)->eh_info;
1357 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1359 /* There should only be one zero terminator, on the last input
1360 file supplying .eh_frame (crtend.o). Remove any others. */
1361 ent->removed = sec->map_head.s != NULL;
1362 else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1365 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1368 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1370 = read_value (abfd, sec->contents + ent->offset + 8 + width,
1371 width, get_DW_EH_PE_signed (ent->fde_encoding));
1376 cookie->rel = cookie->rels + ent->reloc_index;
1377 /* FIXME: octets_per_byte. */
1378 BFD_ASSERT (cookie->rel < cookie->relend
1379 && cookie->rel->r_offset == ent->offset + 8);
1380 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1384 if (bfd_link_pic (info)
1385 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1386 && ent->make_relative == 0)
1387 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1389 static int num_warnings_issued = 0;
1391 /* If a shared library uses absolute pointers
1392 which we cannot turn into PC relative,
1393 don't create the binary search table,
1394 since it is affected by runtime relocations. */
1395 hdr_info->u.dwarf.table = FALSE;
1396 if (num_warnings_issued < 10)
1398 (*info->callbacks->einfo)
1399 /* xgettext:c-format */
1400 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1401 " table being created.\n"), abfd, sec);
1402 num_warnings_issued ++;
1404 else if (num_warnings_issued == 10)
1406 (*info->callbacks->einfo)
1407 (_("%P: Further warnings about FDE encoding preventing .eh_frame_hdr generation dropped.\n"));
1408 num_warnings_issued ++;
1412 hdr_info->u.dwarf.fde_count++;
1413 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1414 cookie, ent->u.fde.cie_inf);
1420 free (sec_info->cies);
1421 sec_info->cies = NULL;
1424 /* It may be that some .eh_frame input section has greater alignment
1425 than other .eh_frame sections. In that case we run the risk of
1426 padding with zeros before that section, which would be seen as a
1427 zero terminator. Alignment padding must be added *inside* the
1428 last FDE instead. For other FDEs we align according to their
1429 encoding, in order to align FDE address range entries naturally. */
1431 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1439 if (ent->u.cie.per_encoding_aligned8)
1444 eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1445 if (eh_alignment < 4)
1448 offset = (offset + eh_alignment - 1) & -eh_alignment;
1449 ent->new_offset = offset;
1450 offset += size_of_output_cie_fde (ent);
1453 /* Pad the last FDE out to the output section alignment if there are
1454 following sections, in order to ensure no padding between this
1455 section and the next. (Relies on the output section alignment
1456 being the maximum of all input sections alignments, which is the
1457 case unless someone is overriding alignment via scripts.) */
1459 if (sec->map_head.s != NULL
1460 && (sec->map_head.s->size != 4
1461 || sec->map_head.s->map_head.s != NULL))
1462 eh_alignment = 1 << sec->output_section->alignment_power;
1463 offset = (offset + eh_alignment - 1) & -eh_alignment;
1464 sec->rawsize = sec->size;
1466 return offset != sec->rawsize;
1469 /* This function is called for .eh_frame_hdr section after
1470 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1471 input sections. It finalizes the size of .eh_frame_hdr section. */
1474 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1476 struct elf_link_hash_table *htab;
1477 struct eh_frame_hdr_info *hdr_info;
1480 htab = elf_hash_table (info);
1481 hdr_info = &htab->eh_info;
1483 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1485 htab_delete (hdr_info->u.dwarf.cies);
1486 hdr_info->u.dwarf.cies = NULL;
1489 sec = hdr_info->hdr_sec;
1493 if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1495 /* For compact frames we only add the header. The actual table comes
1496 from the .eh_frame_entry sections. */
1501 sec->size = EH_FRAME_HDR_SIZE;
1502 if (hdr_info->u.dwarf.table)
1503 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1506 elf_eh_frame_hdr (abfd) = sec;
1510 /* Return true if there is at least one non-empty .eh_frame section in
1511 input files. Can only be called after ld has mapped input to
1512 output sections, and before sections are stripped. */
1515 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1517 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1522 /* Count only sections which have at least a single CIE or FDE.
1523 There cannot be any CIE or FDE <= 8 bytes. */
1524 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1531 /* Return true if there is at least one .eh_frame_entry section in
1535 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1540 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1542 for (o = abfd->sections; o; o = o->next)
1544 const char *name = bfd_get_section_name (abfd, o);
1546 if (strcmp (name, ".eh_frame_entry")
1547 && !bfd_is_abs_section (o->output_section))
1554 /* This function is called from size_dynamic_sections.
1555 It needs to decide whether .eh_frame_hdr should be output or not,
1556 because when the dynamic symbol table has been sized it is too late
1557 to strip sections. */
1560 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1562 struct elf_link_hash_table *htab;
1563 struct eh_frame_hdr_info *hdr_info;
1564 struct bfd_link_hash_entry *bh = NULL;
1565 struct elf_link_hash_entry *h;
1567 htab = elf_hash_table (info);
1568 hdr_info = &htab->eh_info;
1569 if (hdr_info->hdr_sec == NULL)
1572 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1573 || info->eh_frame_hdr_type == 0
1574 || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1575 && !_bfd_elf_eh_frame_present (info))
1576 || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1577 && !_bfd_elf_eh_frame_entry_present (info)))
1579 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1580 hdr_info->hdr_sec = NULL;
1584 /* Add a hidden symbol so that systems without access to PHDRs can
1586 if (! (_bfd_generic_link_add_one_symbol
1587 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1588 hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1591 h = (struct elf_link_hash_entry *) bh;
1593 h->other = STV_HIDDEN;
1594 get_elf_backend_data
1595 (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1597 if (!hdr_info->frame_hdr_is_compact)
1598 hdr_info->u.dwarf.table = TRUE;
1602 /* Adjust an address in the .eh_frame section. Given OFFSET within
1603 SEC, this returns the new offset in the adjusted .eh_frame section,
1604 or -1 if the address refers to a CIE/FDE which has been removed
1605 or to offset with dynamic relocation which is no longer needed. */
1608 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1609 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1613 struct eh_frame_sec_info *sec_info;
1614 unsigned int lo, hi, mid;
1616 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1618 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1620 if (offset >= sec->rawsize)
1621 return offset - sec->rawsize + sec->size;
1624 hi = sec_info->count;
1628 mid = (lo + hi) / 2;
1629 if (offset < sec_info->entry[mid].offset)
1632 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1638 BFD_ASSERT (lo < hi);
1640 /* FDE or CIE was removed. */
1641 if (sec_info->entry[mid].removed)
1642 return (bfd_vma) -1;
1644 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1645 no need for run-time relocation against the personality field. */
1646 if (sec_info->entry[mid].cie
1647 && sec_info->entry[mid].u.cie.make_per_encoding_relative
1648 && offset == (sec_info->entry[mid].offset + 8
1649 + sec_info->entry[mid].u.cie.personality_offset))
1650 return (bfd_vma) -2;
1652 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1653 relocation against FDE's initial_location field. */
1654 if (!sec_info->entry[mid].cie
1655 && sec_info->entry[mid].make_relative
1656 && offset == sec_info->entry[mid].offset + 8)
1657 return (bfd_vma) -2;
1659 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1660 for run-time relocation against LSDA field. */
1661 if (!sec_info->entry[mid].cie
1662 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1663 && offset == (sec_info->entry[mid].offset + 8
1664 + sec_info->entry[mid].lsda_offset))
1665 return (bfd_vma) -2;
1667 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1668 relocation against DW_CFA_set_loc's arguments. */
1669 if (sec_info->entry[mid].set_loc
1670 && sec_info->entry[mid].make_relative
1671 && (offset >= sec_info->entry[mid].offset + 8
1672 + sec_info->entry[mid].set_loc[1]))
1676 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1677 if (offset == sec_info->entry[mid].offset + 8
1678 + sec_info->entry[mid].set_loc[cnt])
1679 return (bfd_vma) -2;
1682 /* Any new augmentation bytes go before the first relocation. */
1683 return (offset + sec_info->entry[mid].new_offset
1684 - sec_info->entry[mid].offset
1685 + extra_augmentation_string_bytes (sec_info->entry + mid)
1686 + extra_augmentation_data_bytes (sec_info->entry + mid));
1689 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1690 Also check that the contents look sane. */
1693 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1694 asection *sec, bfd_byte *contents)
1696 const struct elf_backend_data *bed;
1697 bfd_byte cantunwind[8];
1701 asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1704 sec->rawsize = sec->size;
1706 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1708 /* Check to make sure that the text section corresponding to this eh_frame_entry
1709 section has not been excluded. In particular, mips16 stub entries will be
1710 excluded outside of the normal process. */
1711 if (sec->flags & SEC_EXCLUDE
1712 || text_sec->flags & SEC_EXCLUDE)
1715 if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1716 sec->output_offset, sec->rawsize))
1719 last_addr = bfd_get_signed_32 (abfd, contents);
1720 /* Check that all the entries are in order. */
1721 for (offset = 8; offset < sec->rawsize; offset += 8)
1723 addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1724 if (addr <= last_addr)
1726 /* xgettext:c-format */
1727 _bfd_error_handler (_("%B: %s not in order"), sec->owner, sec->name);
1734 addr = text_sec->output_section->vma + text_sec->output_offset
1737 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1740 /* xgettext:c-format */
1741 _bfd_error_handler (_("%B: %s invalid input section size"),
1742 sec->owner, sec->name);
1743 bfd_set_error (bfd_error_bad_value);
1746 if (last_addr >= addr + sec->rawsize)
1748 /* xgettext:c-format */
1749 _bfd_error_handler (_("%B: %s points past end of text section"),
1750 sec->owner, sec->name);
1751 bfd_set_error (bfd_error_bad_value);
1755 if (sec->size == sec->rawsize)
1758 bed = get_elf_backend_data (abfd);
1759 BFD_ASSERT (sec->size == sec->rawsize + 8);
1760 BFD_ASSERT ((addr & 1) == 0);
1761 BFD_ASSERT (bed->cant_unwind_opcode);
1763 bfd_put_32 (abfd, addr, cantunwind);
1764 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1765 return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1766 sec->output_offset + sec->rawsize, 8);
1769 /* Write out .eh_frame section. This is called with the relocated
1773 _bfd_elf_write_section_eh_frame (bfd *abfd,
1774 struct bfd_link_info *info,
1778 struct eh_frame_sec_info *sec_info;
1779 struct elf_link_hash_table *htab;
1780 struct eh_frame_hdr_info *hdr_info;
1781 unsigned int ptr_size;
1782 struct eh_cie_fde *ent, *last_ent;
1784 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1785 /* FIXME: octets_per_byte. */
1786 return bfd_set_section_contents (abfd, sec->output_section, contents,
1787 sec->output_offset, sec->size);
1789 ptr_size = (get_elf_backend_data (abfd)
1790 ->elf_backend_eh_frame_address_size (abfd, sec));
1791 BFD_ASSERT (ptr_size != 0);
1793 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1794 htab = elf_hash_table (info);
1795 hdr_info = &htab->eh_info;
1797 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1799 hdr_info->frame_hdr_is_compact = FALSE;
1800 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1801 bfd_malloc (hdr_info->u.dwarf.fde_count
1802 * sizeof (*hdr_info->u.dwarf.array));
1804 if (hdr_info->u.dwarf.array == NULL)
1807 /* The new offsets can be bigger or smaller than the original offsets.
1808 We therefore need to make two passes over the section: one backward
1809 pass to move entries up and one forward pass to move entries down.
1810 The two passes won't interfere with each other because entries are
1812 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1813 if (!ent->removed && ent->new_offset > ent->offset)
1814 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1816 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1817 if (!ent->removed && ent->new_offset < ent->offset)
1818 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1820 last_ent = sec_info->entry + sec_info->count;
1821 for (ent = sec_info->entry; ent < last_ent; ++ent)
1823 unsigned char *buf, *end;
1824 unsigned int new_size;
1831 /* Any terminating FDE must be at the end of the section. */
1832 BFD_ASSERT (ent == last_ent - 1);
1836 buf = contents + ent->new_offset;
1837 end = buf + ent->size;
1838 new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset;
1840 /* Update the size. It may be shrinked. */
1841 bfd_put_32 (abfd, new_size - 4, buf);
1843 /* Filling the extra bytes with DW_CFA_nops. */
1844 if (new_size != ent->size)
1845 memset (end, 0, new_size - ent->size);
1850 if (ent->make_relative
1851 || ent->u.cie.make_lsda_relative
1852 || ent->u.cie.per_encoding_relative)
1855 unsigned int action, extra_string, extra_data;
1856 unsigned int per_width, per_encoding;
1858 /* Need to find 'R' or 'L' augmentation's argument and modify
1859 DW_EH_PE_* value. */
1860 action = ((ent->make_relative ? 1 : 0)
1861 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1862 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1863 extra_string = extra_augmentation_string_bytes (ent);
1864 extra_data = extra_augmentation_data_bytes (ent);
1866 /* Skip length, id and version. */
1869 buf += strlen (aug) + 1;
1870 skip_leb128 (&buf, end);
1871 skip_leb128 (&buf, end);
1872 skip_leb128 (&buf, end);
1875 /* The uleb128 will always be a single byte for the kind
1876 of augmentation strings that we're prepared to handle. */
1877 *buf++ += extra_data;
1881 /* Make room for the new augmentation string and data bytes. */
1882 memmove (buf + extra_string + extra_data, buf, end - buf);
1883 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1884 buf += extra_string;
1885 end += extra_string + extra_data;
1887 if (ent->add_augmentation_size)
1890 *buf++ = extra_data - 1;
1892 if (ent->u.cie.add_fde_encoding)
1894 BFD_ASSERT (action & 1);
1896 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1906 BFD_ASSERT (*buf == ent->lsda_encoding);
1907 *buf = make_pc_relative (*buf, ptr_size);
1913 if (ent->u.cie.make_per_encoding_relative)
1914 *buf = make_pc_relative (*buf, ptr_size);
1915 per_encoding = *buf++;
1916 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1917 BFD_ASSERT (per_width != 0);
1918 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1919 == ent->u.cie.per_encoding_relative);
1920 if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1922 + ((buf - contents + per_width - 1)
1923 & ~((bfd_size_type) per_width - 1)));
1928 val = read_value (abfd, buf, per_width,
1929 get_DW_EH_PE_signed (per_encoding));
1930 if (ent->u.cie.make_per_encoding_relative)
1931 val -= (sec->output_section->vma
1932 + sec->output_offset
1933 + (buf - contents));
1936 val += (bfd_vma) ent->offset - ent->new_offset;
1937 val -= extra_string + extra_data;
1939 write_value (abfd, buf, val, per_width);
1947 BFD_ASSERT (*buf == ent->fde_encoding);
1948 *buf = make_pc_relative (*buf, ptr_size);
1963 bfd_vma value, address;
1966 struct eh_cie_fde *cie;
1969 cie = ent->u.fde.cie_inf;
1971 value = ((ent->new_offset + sec->output_offset + 4)
1972 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1973 bfd_put_32 (abfd, value, buf);
1974 if (bfd_link_relocatable (info))
1977 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1978 value = read_value (abfd, buf, width,
1979 get_DW_EH_PE_signed (ent->fde_encoding));
1983 switch (ent->fde_encoding & 0x70)
1985 case DW_EH_PE_textrel:
1986 BFD_ASSERT (hdr_info == NULL);
1988 case DW_EH_PE_datarel:
1990 switch (abfd->arch_info->arch)
1993 BFD_ASSERT (elf_gp (abfd) != 0);
1994 address += elf_gp (abfd);
1997 (*info->callbacks->einfo)
1998 (_("%P: DW_EH_PE_datarel unspecified"
1999 " for this architecture.\n"));
2003 BFD_ASSERT (htab->hgot != NULL
2004 && ((htab->hgot->root.type
2005 == bfd_link_hash_defined)
2006 || (htab->hgot->root.type
2007 == bfd_link_hash_defweak)));
2009 += (htab->hgot->root.u.def.value
2010 + htab->hgot->root.u.def.section->output_offset
2011 + (htab->hgot->root.u.def.section->output_section
2017 case DW_EH_PE_pcrel:
2018 value += (bfd_vma) ent->offset - ent->new_offset;
2019 address += (sec->output_section->vma
2020 + sec->output_offset
2024 if (ent->make_relative)
2025 value -= (sec->output_section->vma
2026 + sec->output_offset
2027 + ent->new_offset + 8);
2028 write_value (abfd, buf, value, width);
2035 /* The address calculation may overflow, giving us a
2036 value greater than 4G on a 32-bit target when
2037 dwarf_vma is 64-bit. */
2038 if (sizeof (address) > 4 && ptr_size == 4)
2039 address &= 0xffffffff;
2040 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
2042 hdr_info->u.dwarf.array[hdr_info->array_count].range
2043 = read_value (abfd, buf + width, width, FALSE);
2044 hdr_info->u.dwarf.array[hdr_info->array_count++].fde
2045 = (sec->output_section->vma
2046 + sec->output_offset
2050 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
2051 || cie->u.cie.make_lsda_relative)
2053 buf += ent->lsda_offset;
2054 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
2055 value = read_value (abfd, buf, width,
2056 get_DW_EH_PE_signed (ent->lsda_encoding));
2059 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
2060 value += (bfd_vma) ent->offset - ent->new_offset;
2061 else if (cie->u.cie.make_lsda_relative)
2062 value -= (sec->output_section->vma
2063 + sec->output_offset
2064 + ent->new_offset + 8 + ent->lsda_offset);
2065 write_value (abfd, buf, value, width);
2068 else if (ent->add_augmentation_size)
2070 /* Skip the PC and length and insert a zero byte for the
2071 augmentation size. */
2073 memmove (buf + 1, buf, end - buf);
2079 /* Adjust DW_CFA_set_loc. */
2083 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2084 new_offset = ent->new_offset + 8
2085 + extra_augmentation_string_bytes (ent)
2086 + extra_augmentation_data_bytes (ent);
2088 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2090 buf = start + ent->set_loc[cnt];
2092 value = read_value (abfd, buf, width,
2093 get_DW_EH_PE_signed (ent->fde_encoding));
2097 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2098 value += (bfd_vma) ent->offset + 8 - new_offset;
2099 if (ent->make_relative)
2100 value -= (sec->output_section->vma
2101 + sec->output_offset
2102 + new_offset + ent->set_loc[cnt]);
2103 write_value (abfd, buf, value, width);
2109 /* FIXME: octets_per_byte. */
2110 return bfd_set_section_contents (abfd, sec->output_section,
2111 contents, (file_ptr) sec->output_offset,
2115 /* Helper function used to sort .eh_frame_hdr search table by increasing
2116 VMA of FDE initial location. */
2119 vma_compare (const void *a, const void *b)
2121 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2122 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2123 if (p->initial_loc > q->initial_loc)
2125 if (p->initial_loc < q->initial_loc)
2127 if (p->range > q->range)
2129 if (p->range < q->range)
2134 /* Reorder .eh_frame_entry sections to match the associated text sections.
2135 This routine is called during the final linking step, just before writing
2136 the contents. At this stage, sections in the eh_frame_hdr_info are already
2137 sorted in order of increasing text section address and so we simply need
2138 to make the .eh_frame_entrys follow that same order. Note that it is
2139 invalid for a linker script to try to force a particular order of
2140 .eh_frame_entry sections. */
2143 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2145 asection *sec = NULL;
2147 struct eh_frame_hdr_info *hdr_info;
2150 struct bfd_link_order *p;
2152 hdr_info = &elf_hash_table (info)->eh_info;
2154 if (hdr_info->hdr_sec == NULL
2155 || info->eh_frame_hdr_type != COMPACT_EH_HDR
2156 || hdr_info->array_count == 0)
2159 /* Change section output offsets to be in text section order. */
2161 osec = hdr_info->u.compact.entries[0]->output_section;
2162 for (i = 0; i < hdr_info->array_count; i++)
2164 sec = hdr_info->u.compact.entries[i];
2165 if (sec->output_section != osec)
2168 (_("Invalid output section for .eh_frame_entry: %s"),
2169 sec->output_section->name);
2172 sec->output_offset = offset;
2173 offset += sec->size;
2177 /* Fix the link_order to match. */
2178 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2180 if (p->type != bfd_indirect_link_order)
2183 p->offset = p->u.indirect.section->output_offset;
2184 if (p->next != NULL)
2191 (_("Invalid contents in %s section"), osec->name);
2198 /* The .eh_frame_hdr format for Compact EH frames:
2200 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2201 uint32_t count (Number of entries in table)
2202 [array from .eh_frame_entry sections] */
2205 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2207 struct elf_link_hash_table *htab;
2208 struct eh_frame_hdr_info *hdr_info;
2210 const struct elf_backend_data *bed;
2212 bfd_byte contents[8];
2215 htab = elf_hash_table (info);
2216 hdr_info = &htab->eh_info;
2217 sec = hdr_info->hdr_sec;
2222 for (i = 0; i < sizeof (contents); i++)
2225 contents[0] = COMPACT_EH_HDR;
2226 bed = get_elf_backend_data (abfd);
2228 BFD_ASSERT (bed->compact_eh_encoding);
2229 contents[1] = (*bed->compact_eh_encoding) (info);
2231 count = (sec->output_section->size - 8) / 8;
2232 bfd_put_32 (abfd, count, contents + 4);
2233 return bfd_set_section_contents (abfd, sec->output_section, contents,
2234 (file_ptr) sec->output_offset, sec->size);
2237 /* The .eh_frame_hdr format for DWARF frames:
2239 ubyte version (currently 1)
2240 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
2242 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2243 number (or DW_EH_PE_omit if there is no
2244 binary search table computed))
2245 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2246 or DW_EH_PE_omit if not present.
2247 DW_EH_PE_datarel is using address of
2248 .eh_frame_hdr section start as base)
2249 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2250 optionally followed by:
2251 [encoded] fde_count (total number of FDEs in .eh_frame section)
2252 fde_count x [encoded] initial_loc, fde
2253 (array of encoded pairs containing
2254 FDE initial_location field and FDE address,
2255 sorted by increasing initial_loc). */
2258 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2260 struct elf_link_hash_table *htab;
2261 struct eh_frame_hdr_info *hdr_info;
2263 bfd_boolean retval = TRUE;
2265 htab = elf_hash_table (info);
2266 hdr_info = &htab->eh_info;
2267 sec = hdr_info->hdr_sec;
2269 asection *eh_frame_sec;
2271 bfd_vma encoded_eh_frame;
2273 size = EH_FRAME_HDR_SIZE;
2274 if (hdr_info->u.dwarf.array
2275 && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2276 size += 4 + hdr_info->u.dwarf.fde_count * 8;
2277 contents = (bfd_byte *) bfd_malloc (size);
2278 if (contents == NULL)
2281 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2282 if (eh_frame_sec == NULL)
2288 memset (contents, 0, EH_FRAME_HDR_SIZE);
2291 /* .eh_frame offset. */
2292 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2293 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2295 if (hdr_info->u.dwarf.array
2296 && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2298 /* FDE count encoding. */
2299 contents[2] = DW_EH_PE_udata4;
2300 /* Search table encoding. */
2301 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2305 contents[2] = DW_EH_PE_omit;
2306 contents[3] = DW_EH_PE_omit;
2308 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2310 if (contents[2] != DW_EH_PE_omit)
2313 bfd_boolean overlap, overflow;
2315 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2316 contents + EH_FRAME_HDR_SIZE);
2317 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2318 sizeof (*hdr_info->u.dwarf.array), vma_compare);
2321 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2325 val = hdr_info->u.dwarf.array[i].initial_loc
2326 - sec->output_section->vma;
2327 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2328 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2329 && (hdr_info->u.dwarf.array[i].initial_loc
2330 != sec->output_section->vma + val))
2332 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2333 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2334 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2335 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2336 && (hdr_info->u.dwarf.array[i].fde
2337 != sec->output_section->vma + val))
2339 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2341 && (hdr_info->u.dwarf.array[i].initial_loc
2342 < (hdr_info->u.dwarf.array[i - 1].initial_loc
2343 + hdr_info->u.dwarf.array[i - 1].range)))
2347 (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
2349 (*info->callbacks->einfo)
2350 (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2351 if (overflow || overlap)
2353 bfd_set_error (bfd_error_bad_value);
2358 /* FIXME: octets_per_byte. */
2359 if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2360 (file_ptr) sec->output_offset,
2365 if (hdr_info->u.dwarf.array != NULL)
2366 free (hdr_info->u.dwarf.array);
2370 /* Write out .eh_frame_hdr section. This must be called after
2371 _bfd_elf_write_section_eh_frame has been called on all input
2372 .eh_frame sections. */
2375 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2377 struct elf_link_hash_table *htab;
2378 struct eh_frame_hdr_info *hdr_info;
2381 htab = elf_hash_table (info);
2382 hdr_info = &htab->eh_info;
2383 sec = hdr_info->hdr_sec;
2385 if (info->eh_frame_hdr_type == 0 || sec == NULL)
2388 if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2389 return write_compact_eh_frame_hdr (abfd, info);
2391 return write_dwarf_eh_frame_hdr (abfd, info);
2394 /* Return the width of FDE addresses. This is the default implementation. */
2397 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2399 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2402 /* Decide whether we can use a PC-relative encoding within the given
2403 EH frame section. This is the default implementation. */
2406 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2407 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2408 asection *eh_frame_section ATTRIBUTE_UNUSED)
2413 /* Select an encoding for the given address. Preference is given to
2414 PC-relative addressing modes. */
2417 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2418 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2419 asection *osec, bfd_vma offset,
2420 asection *loc_sec, bfd_vma loc_offset,
2423 *encoded = osec->vma + offset -
2424 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2425 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;