1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2015 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 /* Examine each .eh_frame_entry section and discard those
456 those that are marked SEC_EXCLUDE. */
459 bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
462 for (i = 0; i < hdr_info->array_count; i++)
464 if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
467 for (j = i + 1; j < hdr_info->array_count; j++)
468 hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
470 hdr_info->array_count--;
471 hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
477 /* Add a .eh_frame_entry section. */
480 bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
483 if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
485 if (hdr_info->u.compact.allocated_entries == 0)
487 hdr_info->frame_hdr_is_compact = TRUE;
488 hdr_info->u.compact.allocated_entries = 2;
489 hdr_info->u.compact.entries =
490 bfd_malloc (hdr_info->u.compact.allocated_entries
491 * sizeof (hdr_info->u.compact.entries[0]));
495 hdr_info->u.compact.allocated_entries *= 2;
496 hdr_info->u.compact.entries =
497 bfd_realloc (hdr_info->u.compact.entries,
498 hdr_info->u.compact.allocated_entries
499 * sizeof (hdr_info->u.compact.entries[0]));
502 BFD_ASSERT (hdr_info->u.compact.entries);
505 hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
508 /* Parse a .eh_frame_entry section. Figure out which text section it
512 _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
513 asection *sec, struct elf_reloc_cookie *cookie)
515 struct elf_link_hash_table *htab;
516 struct eh_frame_hdr_info *hdr_info;
517 unsigned long r_symndx;
520 htab = elf_hash_table (info);
521 hdr_info = &htab->eh_info;
524 || sec->sec_info_type != SEC_INFO_TYPE_NONE)
529 if (sec->output_section && bfd_is_abs_section (sec->output_section))
531 /* At least one of the sections is being discarded from the
532 link, so we should just ignore them. */
536 if (cookie->rel == cookie->relend)
539 /* The first relocation is the function start. */
540 r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
541 if (r_symndx == STN_UNDEF)
544 text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
546 if (text_sec == NULL)
549 elf_section_eh_frame_entry (text_sec) = sec;
550 if (text_sec->output_section
551 && bfd_is_abs_section (text_sec->output_section))
552 sec->flags |= SEC_EXCLUDE;
554 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
555 elf_section_data (sec)->sec_info = text_sec;
556 bfd_elf_record_eh_frame_entry (hdr_info, sec);
560 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
561 information in the section's sec_info field on success. COOKIE
562 describes the relocations in SEC. */
565 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
566 asection *sec, struct elf_reloc_cookie *cookie)
568 #define REQUIRE(COND) \
571 goto free_no_table; \
574 bfd_byte *ehbuf = NULL, *buf, *end;
576 struct eh_cie_fde *this_inf;
577 unsigned int hdr_length, hdr_id;
578 unsigned int cie_count;
579 struct cie *cie, *local_cies = NULL;
580 struct elf_link_hash_table *htab;
581 struct eh_frame_hdr_info *hdr_info;
582 struct eh_frame_sec_info *sec_info = NULL;
583 unsigned int ptr_size;
584 unsigned int num_cies;
585 unsigned int num_entries;
586 elf_gc_mark_hook_fn gc_mark_hook;
588 htab = elf_hash_table (info);
589 hdr_info = &htab->eh_info;
592 || sec->sec_info_type != SEC_INFO_TYPE_NONE)
594 /* This file does not contain .eh_frame information. */
598 if (bfd_is_abs_section (sec->output_section))
600 /* At least one of the sections is being discarded from the
601 link, so we should just ignore them. */
605 /* Read the frame unwind information from abfd. */
607 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
610 && bfd_get_32 (abfd, ehbuf) == 0
611 && cookie->rel == cookie->relend)
613 /* Empty .eh_frame section. */
618 /* If .eh_frame section size doesn't fit into int, we cannot handle
619 it (it would need to use 64-bit .eh_frame format anyway). */
620 REQUIRE (sec->size == (unsigned int) sec->size);
622 ptr_size = (get_elf_backend_data (abfd)
623 ->elf_backend_eh_frame_address_size (abfd, sec));
624 REQUIRE (ptr_size != 0);
626 /* Go through the section contents and work out how many FDEs and
629 end = ehbuf + sec->size;
636 /* Read the length of the entry. */
637 REQUIRE (skip_bytes (&buf, end, 4));
638 hdr_length = bfd_get_32 (abfd, buf - 4);
640 /* 64-bit .eh_frame is not supported. */
641 REQUIRE (hdr_length != 0xffffffff);
645 REQUIRE (skip_bytes (&buf, end, 4));
646 hdr_id = bfd_get_32 (abfd, buf - 4);
650 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
653 sec_info = (struct eh_frame_sec_info *)
654 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
655 + (num_entries - 1) * sizeof (struct eh_cie_fde));
658 /* We need to have a "struct cie" for each CIE in this section. */
659 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
660 REQUIRE (local_cies);
662 /* FIXME: octets_per_byte. */
663 #define ENSURE_NO_RELOCS(buf) \
664 while (cookie->rel < cookie->relend \
665 && (cookie->rel->r_offset \
666 < (bfd_size_type) ((buf) - ehbuf))) \
668 REQUIRE (cookie->rel->r_info == 0); \
672 /* FIXME: octets_per_byte. */
673 #define SKIP_RELOCS(buf) \
674 while (cookie->rel < cookie->relend \
675 && (cookie->rel->r_offset \
676 < (bfd_size_type) ((buf) - ehbuf))) \
679 /* FIXME: octets_per_byte. */
680 #define GET_RELOC(buf) \
681 ((cookie->rel < cookie->relend \
682 && (cookie->rel->r_offset \
683 == (bfd_size_type) ((buf) - ehbuf))) \
684 ? cookie->rel : NULL)
688 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
689 while ((bfd_size_type) (buf - ehbuf) != sec->size)
692 bfd_byte *start, *insns, *insns_end;
693 bfd_size_type length;
694 unsigned int set_loc_count;
696 this_inf = sec_info->entry + sec_info->count;
699 /* Read the length of the entry. */
700 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
701 hdr_length = bfd_get_32 (abfd, buf - 4);
703 /* The CIE/FDE must be fully contained in this input section. */
704 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
705 end = buf + hdr_length;
707 this_inf->offset = last_fde - ehbuf;
708 this_inf->size = 4 + hdr_length;
709 this_inf->reloc_index = cookie->rel - cookie->rels;
713 /* A zero-length CIE should only be found at the end of
715 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
716 ENSURE_NO_RELOCS (buf);
721 REQUIRE (skip_bytes (&buf, end, 4));
722 hdr_id = bfd_get_32 (abfd, buf - 4);
726 unsigned int initial_insn_length;
731 /* Point CIE to one of the section-local cie structures. */
732 cie = local_cies + cie_count++;
734 cie->cie_inf = this_inf;
735 cie->length = hdr_length;
737 REQUIRE (read_byte (&buf, end, &cie->version));
739 /* Cannot handle unknown versions. */
740 REQUIRE (cie->version == 1
742 || cie->version == 4);
743 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
745 strcpy (cie->augmentation, (char *) buf);
746 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
747 ENSURE_NO_RELOCS (buf);
748 if (buf[0] == 'e' && buf[1] == 'h')
750 /* GCC < 3.0 .eh_frame CIE */
751 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
752 is private to each CIE, so we don't need it for anything.
754 REQUIRE (skip_bytes (&buf, end, ptr_size));
757 if (cie->version >= 4)
759 REQUIRE (buf + 1 < end);
760 REQUIRE (buf[0] == ptr_size);
761 REQUIRE (buf[1] == 0);
764 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
765 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
766 if (cie->version == 1)
769 cie->ra_column = *buf++;
772 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
773 ENSURE_NO_RELOCS (buf);
774 cie->lsda_encoding = DW_EH_PE_omit;
775 cie->fde_encoding = DW_EH_PE_omit;
776 cie->per_encoding = DW_EH_PE_omit;
777 aug = cie->augmentation;
778 if (aug[0] != 'e' || aug[1] != 'h')
783 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
784 ENSURE_NO_RELOCS (buf);
791 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
792 ENSURE_NO_RELOCS (buf);
793 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
796 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
797 ENSURE_NO_RELOCS (buf);
798 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
806 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
807 per_width = get_DW_EH_PE_width (cie->per_encoding,
810 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
812 length = -(buf - ehbuf) & (per_width - 1);
813 REQUIRE (skip_bytes (&buf, end, length));
815 this_inf->u.cie.personality_offset = buf - start;
816 ENSURE_NO_RELOCS (buf);
817 /* Ensure we have a reloc here. */
818 REQUIRE (GET_RELOC (buf));
819 cie->personality.reloc_index
820 = cookie->rel - cookie->rels;
821 /* Cope with MIPS-style composite relocations. */
824 while (GET_RELOC (buf) != NULL);
825 REQUIRE (skip_bytes (&buf, end, per_width));
829 /* Unrecognized augmentation. Better bail out. */
834 /* For shared libraries, try to get rid of as many RELATIVE relocs
837 && !info->relocatable
838 && (get_elf_backend_data (abfd)
839 ->elf_backend_can_make_relative_eh_frame
842 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
843 this_inf->make_relative = 1;
844 /* If the CIE doesn't already have an 'R' entry, it's fairly
845 easy to add one, provided that there's no aligned data
846 after the augmentation string. */
847 else if (cie->fde_encoding == DW_EH_PE_omit
848 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
850 if (*cie->augmentation == 0)
851 this_inf->add_augmentation_size = 1;
852 this_inf->u.cie.add_fde_encoding = 1;
853 this_inf->make_relative = 1;
856 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
857 cie->can_make_lsda_relative = 1;
860 /* If FDE encoding was not specified, it defaults to
862 if (cie->fde_encoding == DW_EH_PE_omit)
863 cie->fde_encoding = DW_EH_PE_absptr;
865 initial_insn_length = end - buf;
866 cie->initial_insn_length = initial_insn_length;
867 memcpy (cie->initial_instructions, buf,
868 initial_insn_length <= sizeof (cie->initial_instructions)
869 ? initial_insn_length : sizeof (cie->initial_instructions));
871 buf += initial_insn_length;
872 ENSURE_NO_RELOCS (buf);
874 if (!info->relocatable)
876 /* Keep info for merging cies. */
877 this_inf->u.cie.u.full_cie = cie;
878 this_inf->u.cie.per_encoding_relative
879 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
884 /* Find the corresponding CIE. */
885 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
886 for (cie = local_cies; cie < local_cies + cie_count; cie++)
887 if (cie_offset == cie->cie_inf->offset)
890 /* Ensure this FDE references one of the CIEs in this input
892 REQUIRE (cie != local_cies + cie_count);
893 this_inf->u.fde.cie_inf = cie->cie_inf;
894 this_inf->make_relative = cie->cie_inf->make_relative;
895 this_inf->add_augmentation_size
896 = cie->cie_inf->add_augmentation_size;
898 ENSURE_NO_RELOCS (buf);
899 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
903 REQUIRE (GET_RELOC (buf));
905 /* Chain together the FDEs for each section. */
906 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
907 /* RSEC will be NULL if FDE was cleared out as it was belonging to
908 a discarded SHT_GROUP. */
911 REQUIRE (rsec->owner == abfd);
912 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
913 elf_fde_list (rsec) = this_inf;
917 /* Skip the initial location and address range. */
919 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
920 REQUIRE (skip_bytes (&buf, end, 2 * length));
922 SKIP_RELOCS (buf - length);
923 if (!GET_RELOC (buf - length)
924 && read_value (abfd, buf - length, length, FALSE) == 0)
926 (*info->callbacks->minfo)
927 (_("discarding zero address range FDE in %B(%A).\n"),
929 this_inf->u.fde.cie_inf = NULL;
932 /* Skip the augmentation size, if present. */
933 if (cie->augmentation[0] == 'z')
934 REQUIRE (read_uleb128 (&buf, end, &length));
938 /* Of the supported augmentation characters above, only 'L'
939 adds augmentation data to the FDE. This code would need to
940 be adjusted if any future augmentations do the same thing. */
941 if (cie->lsda_encoding != DW_EH_PE_omit)
944 if (cie->can_make_lsda_relative && GET_RELOC (buf))
945 cie->cie_inf->u.cie.make_lsda_relative = 1;
946 this_inf->lsda_offset = buf - start;
947 /* If there's no 'z' augmentation, we don't know where the
948 CFA insns begin. Assume no padding. */
949 if (cie->augmentation[0] != 'z')
953 /* Skip over the augmentation data. */
954 REQUIRE (skip_bytes (&buf, end, length));
957 buf = last_fde + 4 + hdr_length;
959 /* For NULL RSEC (cleared FDE belonging to a discarded section)
960 the relocations are commonly cleared. We do not sanity check if
961 all these relocations are cleared as (1) relocations to
962 .gcc_except_table will remain uncleared (they will get dropped
963 with the drop of this unused FDE) and (2) BFD already safely drops
964 relocations of any type to .eh_frame by
965 elf_section_ignore_discarded_relocs.
966 TODO: The .gcc_except_table entries should be also filtered as
967 .eh_frame entries; or GCC could rather use COMDAT for them. */
971 /* Try to interpret the CFA instructions and find the first
972 padding nop. Shrink this_inf's size so that it doesn't
973 include the padding. */
974 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
976 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
977 /* If we don't understand the CFA instructions, we can't know
978 what needs to be adjusted there. */
979 if (insns_end == NULL
980 /* For the time being we don't support DW_CFA_set_loc in
982 || (set_loc_count && this_inf->cie))
984 this_inf->size -= end - insns_end;
985 if (insns_end != end && this_inf->cie)
987 cie->initial_insn_length -= end - insns_end;
988 cie->length -= end - insns_end;
991 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
992 || this_inf->make_relative))
997 this_inf->set_loc = (unsigned int *)
998 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
999 REQUIRE (this_inf->set_loc);
1000 this_inf->set_loc[0] = set_loc_count;
1005 if (*p == DW_CFA_set_loc)
1006 this_inf->set_loc[++cnt] = p + 1 - start;
1007 REQUIRE (skip_cfa_op (&p, end, length));
1011 this_inf->removed = 1;
1012 this_inf->fde_encoding = cie->fde_encoding;
1013 this_inf->lsda_encoding = cie->lsda_encoding;
1016 BFD_ASSERT (sec_info->count == num_entries);
1017 BFD_ASSERT (cie_count == num_cies);
1019 elf_section_data (sec)->sec_info = sec_info;
1020 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1021 if (!info->relocatable)
1023 /* Keep info for merging cies. */
1024 sec_info->cies = local_cies;
1030 (*info->callbacks->einfo)
1031 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
1033 hdr_info->u.dwarf.table = FALSE;
1044 /* Order eh_frame_hdr entries by the VMA of their text section. */
1047 cmp_eh_frame_hdr (const void *a, const void *b)
1053 sec = *(asection *const *)a;
1054 sec = (asection *) elf_section_data (sec)->sec_info;
1055 text_a = sec->output_section->vma + sec->output_offset;
1056 sec = *(asection *const *)b;
1057 sec = (asection *) elf_section_data (sec)->sec_info;
1058 text_b = sec->output_section->vma + sec->output_offset;
1060 if (text_a < text_b)
1062 return text_a > text_b;
1066 /* Add space for a CANTUNWIND terminator to SEC if the text sections
1067 referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1070 add_eh_frame_hdr_terminator (asection *sec,
1079 /* See if there is a gap (presumably a text section without unwind info)
1080 between these two entries. */
1081 text_sec = (asection *) elf_section_data (sec)->sec_info;
1082 end = text_sec->output_section->vma + text_sec->output_offset
1084 text_sec = (asection *) elf_section_data (next)->sec_info;
1085 next_start = text_sec->output_section->vma + text_sec->output_offset;
1086 if (end == next_start)
1090 /* Add space for a CANTUNWIND terminator. */
1092 sec->rawsize = sec->size;
1094 bfd_set_section_size (sec->owner, sec, sec->size + 8);
1097 /* Finish a pass over all .eh_frame_entry sections. */
1100 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1102 struct eh_frame_hdr_info *hdr_info;
1105 hdr_info = &elf_hash_table (info)->eh_info;
1107 if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1108 || hdr_info->array_count == 0)
1111 bfd_elf_discard_eh_frame_entry (hdr_info);
1113 qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1114 sizeof (asection *), cmp_eh_frame_hdr);
1116 for (i = 0; i < hdr_info->array_count - 1; i++)
1118 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1119 hdr_info->u.compact.entries[i + 1]);
1122 /* Add a CANTUNWIND terminator after the last entry. */
1123 add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1127 /* Mark all relocations against CIE or FDE ENT, which occurs in
1128 .eh_frame section SEC. COOKIE describes the relocations in SEC;
1129 its "rel" field can be changed freely. */
1132 mark_entry (struct bfd_link_info *info, asection *sec,
1133 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1134 struct elf_reloc_cookie *cookie)
1136 /* FIXME: octets_per_byte. */
1137 for (cookie->rel = cookie->rels + ent->reloc_index;
1138 cookie->rel < cookie->relend
1139 && cookie->rel->r_offset < ent->offset + ent->size;
1141 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1147 /* Mark all the relocations against FDEs that relate to code in input
1148 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1149 relocations are described by COOKIE. */
1152 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1153 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1154 struct elf_reloc_cookie *cookie)
1156 struct eh_cie_fde *fde, *cie;
1158 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1160 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1163 /* At this stage, all cie_inf fields point to local CIEs, so we
1164 can use the same cookie to refer to them. */
1165 cie = fde->u.fde.cie_inf;
1166 if (cie != NULL && !cie->u.cie.gc_mark)
1168 cie->u.cie.gc_mark = 1;
1169 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1176 /* Input section SEC of ABFD is an .eh_frame section that contains the
1177 CIE described by CIE_INF. Return a version of CIE_INF that is going
1178 to be kept in the output, adding CIE_INF to the output if necessary.
1180 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1181 relocations in REL. */
1183 static struct eh_cie_fde *
1184 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1185 struct eh_frame_hdr_info *hdr_info,
1186 struct elf_reloc_cookie *cookie,
1187 struct eh_cie_fde *cie_inf)
1189 unsigned long r_symndx;
1190 struct cie *cie, *new_cie;
1191 Elf_Internal_Rela *rel;
1194 /* Use CIE_INF if we have already decided to keep it. */
1195 if (!cie_inf->removed)
1198 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1199 if (cie_inf->u.cie.merged)
1200 return cie_inf->u.cie.u.merged_with;
1202 cie = cie_inf->u.cie.u.full_cie;
1204 /* Assume we will need to keep CIE_INF. */
1205 cie_inf->removed = 0;
1206 cie_inf->u.cie.u.sec = sec;
1208 /* If we are not merging CIEs, use CIE_INF. */
1212 if (cie->per_encoding != DW_EH_PE_omit)
1214 bfd_boolean per_binds_local;
1216 /* Work out the address of personality routine, or at least
1217 enough info that we could calculate the address had we made a
1218 final section layout. The symbol on the reloc is enough,
1219 either the hash for a global, or (bfd id, index) pair for a
1220 local. The assumption here is that no one uses addends on
1222 rel = cookie->rels + cie->personality.reloc_index;
1223 memset (&cie->personality, 0, sizeof (cie->personality));
1225 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1226 r_symndx = ELF64_R_SYM (rel->r_info);
1229 r_symndx = ELF32_R_SYM (rel->r_info);
1230 if (r_symndx >= cookie->locsymcount
1231 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1233 struct elf_link_hash_entry *h;
1235 r_symndx -= cookie->extsymoff;
1236 h = cookie->sym_hashes[r_symndx];
1238 while (h->root.type == bfd_link_hash_indirect
1239 || h->root.type == bfd_link_hash_warning)
1240 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1242 cie->personality.h = h;
1243 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1247 Elf_Internal_Sym *sym;
1250 sym = &cookie->locsyms[r_symndx];
1251 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1252 if (sym_sec == NULL)
1255 if (sym_sec->kept_section != NULL)
1256 sym_sec = sym_sec->kept_section;
1257 if (sym_sec->output_section == NULL)
1260 cie->local_personality = 1;
1261 cie->personality.sym.bfd_id = abfd->id;
1262 cie->personality.sym.index = r_symndx;
1263 per_binds_local = TRUE;
1268 && !info->relocatable
1269 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1270 && (get_elf_backend_data (abfd)
1271 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1273 cie_inf->u.cie.make_per_encoding_relative = 1;
1274 cie_inf->u.cie.per_encoding_relative = 1;
1278 /* See if we can merge this CIE with an earlier one. */
1279 cie_compute_hash (cie);
1280 if (hdr_info->u.dwarf.cies == NULL)
1282 hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1283 if (hdr_info->u.dwarf.cies == NULL)
1286 loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1291 new_cie = (struct cie *) *loc;
1292 if (new_cie == NULL)
1294 /* Keep CIE_INF and record it in the hash table. */
1295 new_cie = (struct cie *) malloc (sizeof (struct cie));
1296 if (new_cie == NULL)
1299 memcpy (new_cie, cie, sizeof (struct cie));
1304 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1305 cie_inf->removed = 1;
1306 cie_inf->u.cie.merged = 1;
1307 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1308 if (cie_inf->u.cie.make_lsda_relative)
1309 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1311 return new_cie->cie_inf;
1314 /* This function is called for each input file before the .eh_frame
1315 section is relocated. It discards duplicate CIEs and FDEs for discarded
1316 functions. The function returns TRUE iff any entries have been
1320 _bfd_elf_discard_section_eh_frame
1321 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1322 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1323 struct elf_reloc_cookie *cookie)
1325 struct eh_cie_fde *ent;
1326 struct eh_frame_sec_info *sec_info;
1327 struct eh_frame_hdr_info *hdr_info;
1328 unsigned int ptr_size, offset;
1330 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1333 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1334 if (sec_info == NULL)
1337 ptr_size = (get_elf_backend_data (sec->owner)
1338 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1340 hdr_info = &elf_hash_table (info)->eh_info;
1341 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1343 /* There should only be one zero terminator, on the last input
1344 file supplying .eh_frame (crtend.o). Remove any others. */
1345 ent->removed = sec->map_head.s != NULL;
1346 else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1349 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1352 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1354 = read_value (abfd, sec->contents + ent->offset + 8 + width,
1355 width, get_DW_EH_PE_signed (ent->fde_encoding));
1360 cookie->rel = cookie->rels + ent->reloc_index;
1361 /* FIXME: octets_per_byte. */
1362 BFD_ASSERT (cookie->rel < cookie->relend
1363 && cookie->rel->r_offset == ent->offset + 8);
1364 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1369 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1370 && ent->make_relative == 0)
1371 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1373 /* If a shared library uses absolute pointers
1374 which we cannot turn into PC relative,
1375 don't create the binary search table,
1376 since it is affected by runtime relocations. */
1377 hdr_info->u.dwarf.table = FALSE;
1378 (*info->callbacks->einfo)
1379 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1380 " table being created.\n"), abfd, sec);
1383 hdr_info->u.dwarf.fde_count++;
1384 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1385 cookie, ent->u.fde.cie_inf);
1391 free (sec_info->cies);
1392 sec_info->cies = NULL;
1396 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1399 ent->new_offset = offset;
1400 offset += size_of_output_cie_fde (ent, ptr_size);
1403 sec->rawsize = sec->size;
1405 return offset != sec->rawsize;
1408 /* This function is called for .eh_frame_hdr section after
1409 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1410 input sections. It finalizes the size of .eh_frame_hdr section. */
1413 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1415 struct elf_link_hash_table *htab;
1416 struct eh_frame_hdr_info *hdr_info;
1419 htab = elf_hash_table (info);
1420 hdr_info = &htab->eh_info;
1422 if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1424 htab_delete (hdr_info->u.dwarf.cies);
1425 hdr_info->u.dwarf.cies = NULL;
1428 sec = hdr_info->hdr_sec;
1432 if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1434 /* For compact frames we only add the header. The actual table comes
1435 from the .eh_frame_entry sections. */
1440 sec->size = EH_FRAME_HDR_SIZE;
1441 if (hdr_info->u.dwarf.table)
1442 sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1445 elf_eh_frame_hdr (abfd) = sec;
1449 /* Return true if there is at least one non-empty .eh_frame section in
1450 input files. Can only be called after ld has mapped input to
1451 output sections, and before sections are stripped. */
1454 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1456 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1461 /* Count only sections which have at least a single CIE or FDE.
1462 There cannot be any CIE or FDE <= 8 bytes. */
1463 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1470 /* Return true if there is at least one .eh_frame_entry section in
1474 _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1479 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1481 for (o = abfd->sections; o; o = o->next)
1483 const char *name = bfd_get_section_name (abfd, o);
1485 if (strcmp (name, ".eh_frame_entry")
1486 && !bfd_is_abs_section (o->output_section))
1493 /* This function is called from size_dynamic_sections.
1494 It needs to decide whether .eh_frame_hdr should be output or not,
1495 because when the dynamic symbol table has been sized it is too late
1496 to strip sections. */
1499 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1501 struct elf_link_hash_table *htab;
1502 struct eh_frame_hdr_info *hdr_info;
1503 struct bfd_link_hash_entry *bh = NULL;
1504 struct elf_link_hash_entry *h;
1506 htab = elf_hash_table (info);
1507 hdr_info = &htab->eh_info;
1508 if (hdr_info->hdr_sec == NULL)
1511 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1512 || info->eh_frame_hdr_type == 0
1513 || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1514 && !_bfd_elf_eh_frame_present (info))
1515 || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1516 && !_bfd_elf_eh_frame_entry_present (info)))
1518 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1519 hdr_info->hdr_sec = NULL;
1523 /* Add a hidden symbol so that systems without access to PHDRs can
1525 if (! (_bfd_generic_link_add_one_symbol
1526 (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1527 hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1530 h = (struct elf_link_hash_entry *) bh;
1532 h->other = STV_HIDDEN;
1533 get_elf_backend_data
1534 (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1536 if (!hdr_info->frame_hdr_is_compact)
1537 hdr_info->u.dwarf.table = TRUE;
1541 /* Adjust an address in the .eh_frame section. Given OFFSET within
1542 SEC, this returns the new offset in the adjusted .eh_frame section,
1543 or -1 if the address refers to a CIE/FDE which has been removed
1544 or to offset with dynamic relocation which is no longer needed. */
1547 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1548 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1552 struct eh_frame_sec_info *sec_info;
1553 unsigned int lo, hi, mid;
1555 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1557 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1559 if (offset >= sec->rawsize)
1560 return offset - sec->rawsize + sec->size;
1563 hi = sec_info->count;
1567 mid = (lo + hi) / 2;
1568 if (offset < sec_info->entry[mid].offset)
1571 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1577 BFD_ASSERT (lo < hi);
1579 /* FDE or CIE was removed. */
1580 if (sec_info->entry[mid].removed)
1581 return (bfd_vma) -1;
1583 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1584 no need for run-time relocation against the personality field. */
1585 if (sec_info->entry[mid].cie
1586 && sec_info->entry[mid].u.cie.make_per_encoding_relative
1587 && offset == (sec_info->entry[mid].offset + 8
1588 + sec_info->entry[mid].u.cie.personality_offset))
1589 return (bfd_vma) -2;
1591 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1592 relocation against FDE's initial_location field. */
1593 if (!sec_info->entry[mid].cie
1594 && sec_info->entry[mid].make_relative
1595 && offset == sec_info->entry[mid].offset + 8)
1596 return (bfd_vma) -2;
1598 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1599 for run-time relocation against LSDA field. */
1600 if (!sec_info->entry[mid].cie
1601 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1602 && offset == (sec_info->entry[mid].offset + 8
1603 + sec_info->entry[mid].lsda_offset))
1604 return (bfd_vma) -2;
1606 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1607 relocation against DW_CFA_set_loc's arguments. */
1608 if (sec_info->entry[mid].set_loc
1609 && sec_info->entry[mid].make_relative
1610 && (offset >= sec_info->entry[mid].offset + 8
1611 + sec_info->entry[mid].set_loc[1]))
1615 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1616 if (offset == sec_info->entry[mid].offset + 8
1617 + sec_info->entry[mid].set_loc[cnt])
1618 return (bfd_vma) -2;
1621 /* Any new augmentation bytes go before the first relocation. */
1622 return (offset + sec_info->entry[mid].new_offset
1623 - sec_info->entry[mid].offset
1624 + extra_augmentation_string_bytes (sec_info->entry + mid)
1625 + extra_augmentation_data_bytes (sec_info->entry + mid));
1628 /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1629 Also check that the contents look sane. */
1632 _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1633 asection *sec, bfd_byte *contents)
1635 const struct elf_backend_data *bed;
1636 bfd_byte cantunwind[8];
1640 asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1643 sec->rawsize = sec->size;
1645 BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1647 /* Check to make sure that the text section corresponding to this eh_frame_entry
1648 section has not been excluded. In particular, mips16 stub entries will be
1649 excluded outside of the normal process. */
1650 if (sec->flags & SEC_EXCLUDE
1651 || text_sec->flags & SEC_EXCLUDE)
1654 if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1655 sec->output_offset, sec->rawsize))
1658 last_addr = bfd_get_signed_32 (abfd, contents);
1659 /* Check that all the entries are in order. */
1660 for (offset = 8; offset < sec->rawsize; offset += 8)
1662 addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1663 if (addr <= last_addr)
1665 (*_bfd_error_handler) (_("%B: %s not in order"), sec->owner, sec->name);
1672 addr = text_sec->output_section->vma + text_sec->output_offset
1675 addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1678 (*_bfd_error_handler) (_("%B: %s invalid input section size"),
1679 sec->owner, sec->name);
1680 bfd_set_error (bfd_error_bad_value);
1683 if (last_addr >= addr + sec->rawsize)
1685 (*_bfd_error_handler) (_("%B: %s points past end of text section"),
1686 sec->owner, sec->name);
1687 bfd_set_error (bfd_error_bad_value);
1691 if (sec->size == sec->rawsize)
1694 bed = get_elf_backend_data (abfd);
1695 BFD_ASSERT (sec->size == sec->rawsize + 8);
1696 BFD_ASSERT ((addr & 1) == 0);
1697 BFD_ASSERT (bed->cant_unwind_opcode);
1699 bfd_put_32 (abfd, addr, cantunwind);
1700 bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1701 return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1702 sec->output_offset + sec->rawsize, 8);
1705 /* Write out .eh_frame section. This is called with the relocated
1709 _bfd_elf_write_section_eh_frame (bfd *abfd,
1710 struct bfd_link_info *info,
1714 struct eh_frame_sec_info *sec_info;
1715 struct elf_link_hash_table *htab;
1716 struct eh_frame_hdr_info *hdr_info;
1717 unsigned int ptr_size;
1718 struct eh_cie_fde *ent;
1719 bfd_size_type sec_size;
1721 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1722 /* FIXME: octets_per_byte. */
1723 return bfd_set_section_contents (abfd, sec->output_section, contents,
1724 sec->output_offset, sec->size);
1726 ptr_size = (get_elf_backend_data (abfd)
1727 ->elf_backend_eh_frame_address_size (abfd, sec));
1728 BFD_ASSERT (ptr_size != 0);
1730 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1731 htab = elf_hash_table (info);
1732 hdr_info = &htab->eh_info;
1734 if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1736 hdr_info->frame_hdr_is_compact = FALSE;
1737 hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1738 bfd_malloc (hdr_info->u.dwarf.fde_count
1739 * sizeof (*hdr_info->u.dwarf.array));
1741 if (hdr_info->u.dwarf.array == NULL)
1744 /* The new offsets can be bigger or smaller than the original offsets.
1745 We therefore need to make two passes over the section: one backward
1746 pass to move entries up and one forward pass to move entries down.
1747 The two passes won't interfere with each other because entries are
1749 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1750 if (!ent->removed && ent->new_offset > ent->offset)
1751 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1753 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1754 if (!ent->removed && ent->new_offset < ent->offset)
1755 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1757 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1759 unsigned char *buf, *end;
1760 unsigned int new_size;
1767 /* Any terminating FDE must be at the end of the section. */
1768 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1772 buf = contents + ent->new_offset;
1773 end = buf + ent->size;
1774 new_size = size_of_output_cie_fde (ent, ptr_size);
1776 /* Update the size. It may be shrinked. */
1777 bfd_put_32 (abfd, new_size - 4, buf);
1779 /* Filling the extra bytes with DW_CFA_nops. */
1780 if (new_size != ent->size)
1781 memset (end, 0, new_size - ent->size);
1786 if (ent->make_relative
1787 || ent->u.cie.make_lsda_relative
1788 || ent->u.cie.per_encoding_relative)
1791 unsigned int action, extra_string, extra_data;
1792 unsigned int per_width, per_encoding;
1794 /* Need to find 'R' or 'L' augmentation's argument and modify
1795 DW_EH_PE_* value. */
1796 action = ((ent->make_relative ? 1 : 0)
1797 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1798 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1799 extra_string = extra_augmentation_string_bytes (ent);
1800 extra_data = extra_augmentation_data_bytes (ent);
1802 /* Skip length, id and version. */
1805 buf += strlen (aug) + 1;
1806 skip_leb128 (&buf, end);
1807 skip_leb128 (&buf, end);
1808 skip_leb128 (&buf, end);
1811 /* The uleb128 will always be a single byte for the kind
1812 of augmentation strings that we're prepared to handle. */
1813 *buf++ += extra_data;
1817 /* Make room for the new augmentation string and data bytes. */
1818 memmove (buf + extra_string + extra_data, buf, end - buf);
1819 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1820 buf += extra_string;
1821 end += extra_string + extra_data;
1823 if (ent->add_augmentation_size)
1826 *buf++ = extra_data - 1;
1828 if (ent->u.cie.add_fde_encoding)
1830 BFD_ASSERT (action & 1);
1832 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1842 BFD_ASSERT (*buf == ent->lsda_encoding);
1843 *buf = make_pc_relative (*buf, ptr_size);
1849 if (ent->u.cie.make_per_encoding_relative)
1850 *buf = make_pc_relative (*buf, ptr_size);
1851 per_encoding = *buf++;
1852 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1853 BFD_ASSERT (per_width != 0);
1854 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1855 == ent->u.cie.per_encoding_relative);
1856 if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1858 + ((buf - contents + per_width - 1)
1859 & ~((bfd_size_type) per_width - 1)));
1864 val = read_value (abfd, buf, per_width,
1865 get_DW_EH_PE_signed (per_encoding));
1866 if (ent->u.cie.make_per_encoding_relative)
1867 val -= (sec->output_section->vma
1868 + sec->output_offset
1869 + (buf - contents));
1872 val += (bfd_vma) ent->offset - ent->new_offset;
1873 val -= extra_string + extra_data;
1875 write_value (abfd, buf, val, per_width);
1883 BFD_ASSERT (*buf == ent->fde_encoding);
1884 *buf = make_pc_relative (*buf, ptr_size);
1899 bfd_vma value, address;
1902 struct eh_cie_fde *cie;
1905 cie = ent->u.fde.cie_inf;
1907 value = ((ent->new_offset + sec->output_offset + 4)
1908 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1909 bfd_put_32 (abfd, value, buf);
1910 if (info->relocatable)
1913 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1914 value = read_value (abfd, buf, width,
1915 get_DW_EH_PE_signed (ent->fde_encoding));
1919 switch (ent->fde_encoding & 0x70)
1921 case DW_EH_PE_textrel:
1922 BFD_ASSERT (hdr_info == NULL);
1924 case DW_EH_PE_datarel:
1926 switch (abfd->arch_info->arch)
1929 BFD_ASSERT (elf_gp (abfd) != 0);
1930 address += elf_gp (abfd);
1933 (*info->callbacks->einfo)
1934 (_("%P: DW_EH_PE_datarel unspecified"
1935 " for this architecture.\n"));
1939 BFD_ASSERT (htab->hgot != NULL
1940 && ((htab->hgot->root.type
1941 == bfd_link_hash_defined)
1942 || (htab->hgot->root.type
1943 == bfd_link_hash_defweak)));
1945 += (htab->hgot->root.u.def.value
1946 + htab->hgot->root.u.def.section->output_offset
1947 + (htab->hgot->root.u.def.section->output_section
1953 case DW_EH_PE_pcrel:
1954 value += (bfd_vma) ent->offset - ent->new_offset;
1955 address += (sec->output_section->vma
1956 + sec->output_offset
1960 if (ent->make_relative)
1961 value -= (sec->output_section->vma
1962 + sec->output_offset
1963 + ent->new_offset + 8);
1964 write_value (abfd, buf, value, width);
1971 /* The address calculation may overflow, giving us a
1972 value greater than 4G on a 32-bit target when
1973 dwarf_vma is 64-bit. */
1974 if (sizeof (address) > 4 && ptr_size == 4)
1975 address &= 0xffffffff;
1976 hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
1978 hdr_info->u.dwarf.array[hdr_info->array_count].range
1979 = read_value (abfd, buf + width, width, FALSE);
1980 hdr_info->u.dwarf.array[hdr_info->array_count++].fde
1981 = (sec->output_section->vma
1982 + sec->output_offset
1986 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1987 || cie->u.cie.make_lsda_relative)
1989 buf += ent->lsda_offset;
1990 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1991 value = read_value (abfd, buf, width,
1992 get_DW_EH_PE_signed (ent->lsda_encoding));
1995 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1996 value += (bfd_vma) ent->offset - ent->new_offset;
1997 else if (cie->u.cie.make_lsda_relative)
1998 value -= (sec->output_section->vma
1999 + sec->output_offset
2000 + ent->new_offset + 8 + ent->lsda_offset);
2001 write_value (abfd, buf, value, width);
2004 else if (ent->add_augmentation_size)
2006 /* Skip the PC and length and insert a zero byte for the
2007 augmentation size. */
2009 memmove (buf + 1, buf, end - buf);
2015 /* Adjust DW_CFA_set_loc. */
2019 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2020 new_offset = ent->new_offset + 8
2021 + extra_augmentation_string_bytes (ent)
2022 + extra_augmentation_data_bytes (ent);
2024 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2026 buf = start + ent->set_loc[cnt];
2028 value = read_value (abfd, buf, width,
2029 get_DW_EH_PE_signed (ent->fde_encoding));
2033 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2034 value += (bfd_vma) ent->offset + 8 - new_offset;
2035 if (ent->make_relative)
2036 value -= (sec->output_section->vma
2037 + sec->output_offset
2038 + new_offset + ent->set_loc[cnt]);
2039 write_value (abfd, buf, value, width);
2045 /* We don't align the section to its section alignment since the
2046 runtime library only expects all CIE/FDE records aligned at
2047 the pointer size. _bfd_elf_discard_section_eh_frame should
2048 have padded CIE/FDE records to multiple of pointer size with
2049 size_of_output_cie_fde. */
2050 sec_size = sec->size;
2051 if (sec_info->count != 0
2052 && sec_info->entry[sec_info->count - 1].size == 4)
2054 if ((sec_size % ptr_size) != 0)
2057 /* FIXME: octets_per_byte. */
2058 return bfd_set_section_contents (abfd, sec->output_section,
2059 contents, (file_ptr) sec->output_offset,
2063 /* Helper function used to sort .eh_frame_hdr search table by increasing
2064 VMA of FDE initial location. */
2067 vma_compare (const void *a, const void *b)
2069 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2070 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2071 if (p->initial_loc > q->initial_loc)
2073 if (p->initial_loc < q->initial_loc)
2075 if (p->range > q->range)
2077 if (p->range < q->range)
2082 /* Reorder .eh_frame_entry sections to match the associated text sections.
2083 This routine is called during the final linking step, just before writing
2084 the contents. At this stage, sections in the eh_frame_hdr_info are already
2085 sorted in order of increasing text section address and so we simply need
2086 to make the .eh_frame_entrys follow that same order. Note that it is
2087 invalid for a linker script to try to force a particular order of
2088 .eh_frame_entry sections. */
2091 _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2093 asection *sec = NULL;
2095 struct eh_frame_hdr_info *hdr_info;
2098 struct bfd_link_order *p;
2100 hdr_info = &elf_hash_table (info)->eh_info;
2102 if (hdr_info->hdr_sec == NULL
2103 || info->eh_frame_hdr_type != COMPACT_EH_HDR
2104 || hdr_info->array_count == 0)
2107 /* Change section output offsets to be in text section order. */
2109 osec = hdr_info->u.compact.entries[0]->output_section;
2110 for (i = 0; i < hdr_info->array_count; i++)
2112 sec = hdr_info->u.compact.entries[i];
2113 if (sec->output_section != osec)
2115 (*_bfd_error_handler)
2116 (_("Invalid output section for .eh_frame_entry: %s"),
2117 sec->output_section->name);
2120 sec->output_offset = offset;
2121 offset += sec->size;
2125 /* Fix the link_order to match. */
2126 for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2128 if (p->type != bfd_indirect_link_order)
2131 p->offset = p->u.indirect.section->output_offset;
2132 if (p->next != NULL)
2138 (*_bfd_error_handler)
2139 (_("Invalid contents in %s section"), osec->name);
2146 /* The .eh_frame_hdr format for Compact EH frames:
2148 ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2149 uint32_t count (Number of entries in table)
2150 [array from .eh_frame_entry sections] */
2153 write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2155 struct elf_link_hash_table *htab;
2156 struct eh_frame_hdr_info *hdr_info;
2158 const struct elf_backend_data *bed;
2160 bfd_byte contents[8];
2163 htab = elf_hash_table (info);
2164 hdr_info = &htab->eh_info;
2165 sec = hdr_info->hdr_sec;
2170 for (i = 0; i < sizeof (contents); i++)
2173 contents[0] = COMPACT_EH_HDR;
2174 bed = get_elf_backend_data (abfd);
2176 BFD_ASSERT (bed->compact_eh_encoding);
2177 contents[1] = (*bed->compact_eh_encoding) (info);
2179 count = (sec->output_section->size - 8) / 8;
2180 bfd_put_32 (abfd, count, contents + 4);
2181 return bfd_set_section_contents (abfd, sec->output_section, contents,
2182 (file_ptr) sec->output_offset, sec->size);
2185 /* The .eh_frame_hdr format for DWARF frames:
2187 ubyte version (currently 1)
2188 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
2190 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2191 number (or DW_EH_PE_omit if there is no
2192 binary search table computed))
2193 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2194 or DW_EH_PE_omit if not present.
2195 DW_EH_PE_datarel is using address of
2196 .eh_frame_hdr section start as base)
2197 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2198 optionally followed by:
2199 [encoded] fde_count (total number of FDEs in .eh_frame section)
2200 fde_count x [encoded] initial_loc, fde
2201 (array of encoded pairs containing
2202 FDE initial_location field and FDE address,
2203 sorted by increasing initial_loc). */
2206 write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2208 struct elf_link_hash_table *htab;
2209 struct eh_frame_hdr_info *hdr_info;
2211 bfd_boolean retval = TRUE;
2213 htab = elf_hash_table (info);
2214 hdr_info = &htab->eh_info;
2215 sec = hdr_info->hdr_sec;
2217 asection *eh_frame_sec;
2219 bfd_vma encoded_eh_frame;
2221 size = EH_FRAME_HDR_SIZE;
2222 if (hdr_info->u.dwarf.array
2223 && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2224 size += 4 + hdr_info->u.dwarf.fde_count * 8;
2225 contents = (bfd_byte *) bfd_malloc (size);
2226 if (contents == NULL)
2229 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2230 if (eh_frame_sec == NULL)
2236 memset (contents, 0, EH_FRAME_HDR_SIZE);
2239 /* .eh_frame offset. */
2240 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
2241 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
2243 if (hdr_info->u.dwarf.array
2244 && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2246 /* FDE count encoding. */
2247 contents[2] = DW_EH_PE_udata4;
2248 /* Search table encoding. */
2249 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
2253 contents[2] = DW_EH_PE_omit;
2254 contents[3] = DW_EH_PE_omit;
2256 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2258 if (contents[2] != DW_EH_PE_omit)
2261 bfd_boolean overlap, overflow;
2263 bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2264 contents + EH_FRAME_HDR_SIZE);
2265 qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2266 sizeof (*hdr_info->u.dwarf.array), vma_compare);
2269 for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2273 val = hdr_info->u.dwarf.array[i].initial_loc
2274 - sec->output_section->vma;
2275 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2276 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2277 && (hdr_info->u.dwarf.array[i].initial_loc
2278 != sec->output_section->vma + val))
2280 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2281 val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2282 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2283 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2284 && (hdr_info->u.dwarf.array[i].fde
2285 != sec->output_section->vma + val))
2287 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2289 && (hdr_info->u.dwarf.array[i].initial_loc
2290 < (hdr_info->u.dwarf.array[i - 1].initial_loc
2291 + hdr_info->u.dwarf.array[i - 1].range)))
2295 (*info->callbacks->einfo) (_("%P: .eh_frame_hdr entry overflow.\n"));
2297 (*info->callbacks->einfo)
2298 (_("%P: .eh_frame_hdr refers to overlapping FDEs.\n"));
2299 if (overflow || overlap)
2301 bfd_set_error (bfd_error_bad_value);
2306 /* FIXME: octets_per_byte. */
2307 if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2308 (file_ptr) sec->output_offset,
2313 if (hdr_info->u.dwarf.array != NULL)
2314 free (hdr_info->u.dwarf.array);
2318 /* Write out .eh_frame_hdr section. This must be called after
2319 _bfd_elf_write_section_eh_frame has been called on all input
2320 .eh_frame sections. */
2323 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2325 struct elf_link_hash_table *htab;
2326 struct eh_frame_hdr_info *hdr_info;
2329 htab = elf_hash_table (info);
2330 hdr_info = &htab->eh_info;
2331 sec = hdr_info->hdr_sec;
2333 if (info->eh_frame_hdr_type == 0 || sec == NULL)
2336 if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2337 return write_compact_eh_frame_hdr (abfd, info);
2339 return write_dwarf_eh_frame_hdr (abfd, info);
2342 /* Return the width of FDE addresses. This is the default implementation. */
2345 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2347 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2350 /* Decide whether we can use a PC-relative encoding within the given
2351 EH frame section. This is the default implementation. */
2354 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2355 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2356 asection *eh_frame_section ATTRIBUTE_UNUSED)
2361 /* Select an encoding for the given address. Preference is given to
2362 PC-relative addressing modes. */
2365 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2366 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2367 asection *osec, bfd_vma offset,
2368 asection *loc_sec, bfd_vma loc_offset,
2371 *encoded = osec->vma + offset -
2372 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2373 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;