1 /* .eh_frame section optimization.
2 Copyright (C) 2001-2014 Free Software Foundation, Inc.
3 Written by Jakub Jelinek <jakub@redhat.com>.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
28 #define EH_FRAME_HDR_SIZE 8
34 unsigned char version;
35 unsigned char local_personality;
36 char augmentation[20];
38 bfd_signed_vma data_align;
40 bfd_vma augmentation_size;
42 struct elf_link_hash_entry *h;
47 unsigned int reloc_index;
49 struct eh_cie_fde *cie_inf;
50 unsigned char per_encoding;
51 unsigned char lsda_encoding;
52 unsigned char fde_encoding;
53 unsigned char initial_insn_length;
54 unsigned char can_make_lsda_relative;
55 unsigned char initial_instructions[50];
60 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
61 move onto the next byte. Return true on success. */
63 static inline bfd_boolean
64 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
68 *result = *((*iter)++);
72 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
73 Return true it was possible to move LENGTH bytes. */
75 static inline bfd_boolean
76 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
78 if ((bfd_size_type) (end - *iter) < length)
87 /* Move *ITER over an leb128, stopping at END. Return true if the end
88 of the leb128 was found. */
91 skip_leb128 (bfd_byte **iter, bfd_byte *end)
95 if (!read_byte (iter, end, &byte))
101 /* Like skip_leb128, but treat the leb128 as an unsigned value and
102 store it in *VALUE. */
105 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
110 if (!skip_leb128 (iter, end))
116 *value = (*value << 7) | (*--p & 0x7f);
121 /* Like read_uleb128, but for signed values. */
124 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
129 if (!skip_leb128 (iter, end))
133 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
135 *value = (*value << 7) | (*--p & 0x7f);
140 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
143 int get_DW_EH_PE_width (int encoding, int ptr_size)
145 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
147 if ((encoding & 0x60) == 0x60)
150 switch (encoding & 7)
152 case DW_EH_PE_udata2: return 2;
153 case DW_EH_PE_udata4: return 4;
154 case DW_EH_PE_udata8: return 8;
155 case DW_EH_PE_absptr: return ptr_size;
163 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
165 /* Read a width sized value from memory. */
168 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
176 value = bfd_get_signed_16 (abfd, buf);
178 value = bfd_get_16 (abfd, buf);
182 value = bfd_get_signed_32 (abfd, buf);
184 value = bfd_get_32 (abfd, buf);
188 value = bfd_get_signed_64 (abfd, buf);
190 value = bfd_get_64 (abfd, buf);
200 /* Store a width sized value to memory. */
203 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
207 case 2: bfd_put_16 (abfd, value, buf); break;
208 case 4: bfd_put_32 (abfd, value, buf); break;
209 case 8: bfd_put_64 (abfd, value, buf); break;
210 default: BFD_FAIL ();
214 /* Return one if C1 and C2 CIEs can be merged. */
217 cie_eq (const void *e1, const void *e2)
219 const struct cie *c1 = (const struct cie *) e1;
220 const struct cie *c2 = (const struct cie *) e2;
222 if (c1->hash == c2->hash
223 && c1->length == c2->length
224 && c1->version == c2->version
225 && c1->local_personality == c2->local_personality
226 && strcmp (c1->augmentation, c2->augmentation) == 0
227 && strcmp (c1->augmentation, "eh") != 0
228 && c1->code_align == c2->code_align
229 && c1->data_align == c2->data_align
230 && c1->ra_column == c2->ra_column
231 && c1->augmentation_size == c2->augmentation_size
232 && memcmp (&c1->personality, &c2->personality,
233 sizeof (c1->personality)) == 0
234 && (c1->cie_inf->u.cie.u.sec->output_section
235 == c2->cie_inf->u.cie.u.sec->output_section)
236 && c1->per_encoding == c2->per_encoding
237 && c1->lsda_encoding == c2->lsda_encoding
238 && c1->fde_encoding == c2->fde_encoding
239 && c1->initial_insn_length == c2->initial_insn_length
240 && c1->initial_insn_length <= sizeof (c1->initial_instructions)
241 && memcmp (c1->initial_instructions,
242 c2->initial_instructions,
243 c1->initial_insn_length) == 0)
250 cie_hash (const void *e)
252 const struct cie *c = (const struct cie *) e;
257 cie_compute_hash (struct cie *c)
261 h = iterative_hash_object (c->length, h);
262 h = iterative_hash_object (c->version, h);
263 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
264 h = iterative_hash_object (c->code_align, h);
265 h = iterative_hash_object (c->data_align, h);
266 h = iterative_hash_object (c->ra_column, h);
267 h = iterative_hash_object (c->augmentation_size, h);
268 h = iterative_hash_object (c->personality, h);
269 h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
270 h = iterative_hash_object (c->per_encoding, h);
271 h = iterative_hash_object (c->lsda_encoding, h);
272 h = iterative_hash_object (c->fde_encoding, h);
273 h = iterative_hash_object (c->initial_insn_length, h);
274 len = c->initial_insn_length;
275 if (len > sizeof (c->initial_instructions))
276 len = sizeof (c->initial_instructions);
277 h = iterative_hash (c->initial_instructions, len, h);
282 /* Return the number of extra bytes that we'll be inserting into
283 ENTRY's augmentation string. */
285 static INLINE unsigned int
286 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
288 unsigned int size = 0;
291 if (entry->add_augmentation_size)
293 if (entry->u.cie.add_fde_encoding)
299 /* Likewise ENTRY's augmentation data. */
301 static INLINE unsigned int
302 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
304 unsigned int size = 0;
305 if (entry->add_augmentation_size)
307 if (entry->cie && entry->u.cie.add_fde_encoding)
312 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
313 required alignment of ENTRY in bytes. */
316 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
320 if (entry->size == 4)
323 + extra_augmentation_string_bytes (entry)
324 + extra_augmentation_data_bytes (entry)
325 + alignment - 1) & -alignment;
328 /* Assume that the bytes between *ITER and END are CFA instructions.
329 Try to move *ITER past the first instruction and return true on
330 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
333 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
338 if (!read_byte (iter, end, &op))
341 switch (op & 0xc0 ? op & 0xc0 : op)
344 case DW_CFA_advance_loc:
346 case DW_CFA_remember_state:
347 case DW_CFA_restore_state:
348 case DW_CFA_GNU_window_save:
353 case DW_CFA_restore_extended:
354 case DW_CFA_undefined:
355 case DW_CFA_same_value:
356 case DW_CFA_def_cfa_register:
357 case DW_CFA_def_cfa_offset:
358 case DW_CFA_def_cfa_offset_sf:
359 case DW_CFA_GNU_args_size:
360 /* One leb128 argument. */
361 return skip_leb128 (iter, end);
363 case DW_CFA_val_offset:
364 case DW_CFA_val_offset_sf:
365 case DW_CFA_offset_extended:
366 case DW_CFA_register:
368 case DW_CFA_offset_extended_sf:
369 case DW_CFA_GNU_negative_offset_extended:
370 case DW_CFA_def_cfa_sf:
371 /* Two leb128 arguments. */
372 return (skip_leb128 (iter, end)
373 && skip_leb128 (iter, end));
375 case DW_CFA_def_cfa_expression:
376 /* A variable-length argument. */
377 return (read_uleb128 (iter, end, &length)
378 && skip_bytes (iter, end, length));
380 case DW_CFA_expression:
381 case DW_CFA_val_expression:
382 /* A leb128 followed by a variable-length argument. */
383 return (skip_leb128 (iter, end)
384 && read_uleb128 (iter, end, &length)
385 && skip_bytes (iter, end, length));
388 return skip_bytes (iter, end, encoded_ptr_width);
390 case DW_CFA_advance_loc1:
391 return skip_bytes (iter, end, 1);
393 case DW_CFA_advance_loc2:
394 return skip_bytes (iter, end, 2);
396 case DW_CFA_advance_loc4:
397 return skip_bytes (iter, end, 4);
399 case DW_CFA_MIPS_advance_loc8:
400 return skip_bytes (iter, end, 8);
407 /* Try to interpret the bytes between BUF and END as CFA instructions.
408 If every byte makes sense, return a pointer to the first DW_CFA_nop
409 padding byte, or END if there is no padding. Return null otherwise.
410 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
413 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
414 unsigned int *set_loc_count)
420 if (*buf == DW_CFA_nop)
424 if (*buf == DW_CFA_set_loc)
426 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
433 /* Convert absolute encoding ENCODING into PC-relative form.
434 SIZE is the size of a pointer. */
437 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
439 if ((encoding & 0x7f) == DW_EH_PE_absptr)
443 encoding |= DW_EH_PE_sdata2;
446 encoding |= DW_EH_PE_sdata4;
449 encoding |= DW_EH_PE_sdata8;
452 return encoding | DW_EH_PE_pcrel;
455 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
456 information in the section's sec_info field on success. COOKIE
457 describes the relocations in SEC. */
460 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
461 asection *sec, struct elf_reloc_cookie *cookie)
463 #define REQUIRE(COND) \
466 goto free_no_table; \
469 bfd_byte *ehbuf = NULL, *buf, *end;
471 struct eh_cie_fde *this_inf;
472 unsigned int hdr_length, hdr_id;
473 unsigned int cie_count;
474 struct cie *cie, *local_cies = NULL;
475 struct elf_link_hash_table *htab;
476 struct eh_frame_hdr_info *hdr_info;
477 struct eh_frame_sec_info *sec_info = NULL;
478 unsigned int ptr_size;
479 unsigned int num_cies;
480 unsigned int num_entries;
481 elf_gc_mark_hook_fn gc_mark_hook;
483 htab = elf_hash_table (info);
484 hdr_info = &htab->eh_info;
487 || sec->sec_info_type != SEC_INFO_TYPE_NONE)
489 /* This file does not contain .eh_frame information. */
493 if (bfd_is_abs_section (sec->output_section))
495 /* At least one of the sections is being discarded from the
496 link, so we should just ignore them. */
500 /* Read the frame unwind information from abfd. */
502 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
505 && bfd_get_32 (abfd, ehbuf) == 0
506 && cookie->rel == cookie->relend)
508 /* Empty .eh_frame section. */
513 /* If .eh_frame section size doesn't fit into int, we cannot handle
514 it (it would need to use 64-bit .eh_frame format anyway). */
515 REQUIRE (sec->size == (unsigned int) sec->size);
517 ptr_size = (get_elf_backend_data (abfd)
518 ->elf_backend_eh_frame_address_size (abfd, sec));
519 REQUIRE (ptr_size != 0);
521 /* Go through the section contents and work out how many FDEs and
524 end = ehbuf + sec->size;
531 /* Read the length of the entry. */
532 REQUIRE (skip_bytes (&buf, end, 4));
533 hdr_length = bfd_get_32 (abfd, buf - 4);
535 /* 64-bit .eh_frame is not supported. */
536 REQUIRE (hdr_length != 0xffffffff);
540 REQUIRE (skip_bytes (&buf, end, 4));
541 hdr_id = bfd_get_32 (abfd, buf - 4);
545 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
548 sec_info = (struct eh_frame_sec_info *)
549 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
550 + (num_entries - 1) * sizeof (struct eh_cie_fde));
553 /* We need to have a "struct cie" for each CIE in this section. */
554 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
555 REQUIRE (local_cies);
557 /* FIXME: octets_per_byte. */
558 #define ENSURE_NO_RELOCS(buf) \
559 REQUIRE (!(cookie->rel < cookie->relend \
560 && (cookie->rel->r_offset \
561 < (bfd_size_type) ((buf) - ehbuf)) \
562 && cookie->rel->r_info != 0))
564 /* FIXME: octets_per_byte. */
565 #define SKIP_RELOCS(buf) \
566 while (cookie->rel < cookie->relend \
567 && (cookie->rel->r_offset \
568 < (bfd_size_type) ((buf) - ehbuf))) \
571 /* FIXME: octets_per_byte. */
572 #define GET_RELOC(buf) \
573 ((cookie->rel < cookie->relend \
574 && (cookie->rel->r_offset \
575 == (bfd_size_type) ((buf) - ehbuf))) \
576 ? cookie->rel : NULL)
580 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
581 while ((bfd_size_type) (buf - ehbuf) != sec->size)
584 bfd_byte *start, *insns, *insns_end;
585 bfd_size_type length;
586 unsigned int set_loc_count;
588 this_inf = sec_info->entry + sec_info->count;
591 /* Read the length of the entry. */
592 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
593 hdr_length = bfd_get_32 (abfd, buf - 4);
595 /* The CIE/FDE must be fully contained in this input section. */
596 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
597 end = buf + hdr_length;
599 this_inf->offset = last_fde - ehbuf;
600 this_inf->size = 4 + hdr_length;
601 this_inf->reloc_index = cookie->rel - cookie->rels;
605 /* A zero-length CIE should only be found at the end of
607 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
608 ENSURE_NO_RELOCS (buf);
613 REQUIRE (skip_bytes (&buf, end, 4));
614 hdr_id = bfd_get_32 (abfd, buf - 4);
618 unsigned int initial_insn_length;
623 /* Point CIE to one of the section-local cie structures. */
624 cie = local_cies + cie_count++;
626 cie->cie_inf = this_inf;
627 cie->length = hdr_length;
629 REQUIRE (read_byte (&buf, end, &cie->version));
631 /* Cannot handle unknown versions. */
632 REQUIRE (cie->version == 1
634 || cie->version == 4);
635 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
637 strcpy (cie->augmentation, (char *) buf);
638 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
639 ENSURE_NO_RELOCS (buf);
640 if (buf[0] == 'e' && buf[1] == 'h')
642 /* GCC < 3.0 .eh_frame CIE */
643 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
644 is private to each CIE, so we don't need it for anything.
646 REQUIRE (skip_bytes (&buf, end, ptr_size));
649 if (cie->version >= 4)
651 REQUIRE (buf + 1 < end);
652 REQUIRE (buf[0] == ptr_size);
653 REQUIRE (buf[1] == 0);
656 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
657 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
658 if (cie->version == 1)
661 cie->ra_column = *buf++;
664 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
665 ENSURE_NO_RELOCS (buf);
666 cie->lsda_encoding = DW_EH_PE_omit;
667 cie->fde_encoding = DW_EH_PE_omit;
668 cie->per_encoding = DW_EH_PE_omit;
669 aug = cie->augmentation;
670 if (aug[0] != 'e' || aug[1] != 'h')
675 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
676 ENSURE_NO_RELOCS (buf);
683 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
684 ENSURE_NO_RELOCS (buf);
685 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
688 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
689 ENSURE_NO_RELOCS (buf);
690 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
698 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
699 per_width = get_DW_EH_PE_width (cie->per_encoding,
702 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
704 length = -(buf - ehbuf) & (per_width - 1);
705 REQUIRE (skip_bytes (&buf, end, length));
707 this_inf->u.cie.personality_offset = buf - start;
708 ENSURE_NO_RELOCS (buf);
709 /* Ensure we have a reloc here. */
710 REQUIRE (GET_RELOC (buf));
711 cie->personality.reloc_index
712 = cookie->rel - cookie->rels;
713 /* Cope with MIPS-style composite relocations. */
716 while (GET_RELOC (buf) != NULL);
717 REQUIRE (skip_bytes (&buf, end, per_width));
721 /* Unrecognized augmentation. Better bail out. */
726 /* For shared libraries, try to get rid of as many RELATIVE relocs
729 && (get_elf_backend_data (abfd)
730 ->elf_backend_can_make_relative_eh_frame
733 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
734 this_inf->make_relative = 1;
735 /* If the CIE doesn't already have an 'R' entry, it's fairly
736 easy to add one, provided that there's no aligned data
737 after the augmentation string. */
738 else if (cie->fde_encoding == DW_EH_PE_omit
739 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
741 if (*cie->augmentation == 0)
742 this_inf->add_augmentation_size = 1;
743 this_inf->u.cie.add_fde_encoding = 1;
744 this_inf->make_relative = 1;
747 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
748 cie->can_make_lsda_relative = 1;
751 /* If FDE encoding was not specified, it defaults to
753 if (cie->fde_encoding == DW_EH_PE_omit)
754 cie->fde_encoding = DW_EH_PE_absptr;
756 initial_insn_length = end - buf;
757 cie->initial_insn_length = initial_insn_length;
758 memcpy (cie->initial_instructions, buf,
759 initial_insn_length <= sizeof (cie->initial_instructions)
760 ? initial_insn_length : sizeof (cie->initial_instructions));
762 buf += initial_insn_length;
763 ENSURE_NO_RELOCS (buf);
765 if (!info->relocatable)
766 /* Keep info for merging cies. */
767 this_inf->u.cie.u.full_cie = cie;
768 this_inf->u.cie.per_encoding_relative
769 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
773 /* Find the corresponding CIE. */
774 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
775 for (cie = local_cies; cie < local_cies + cie_count; cie++)
776 if (cie_offset == cie->cie_inf->offset)
779 /* Ensure this FDE references one of the CIEs in this input
781 REQUIRE (cie != local_cies + cie_count);
782 this_inf->u.fde.cie_inf = cie->cie_inf;
783 this_inf->make_relative = cie->cie_inf->make_relative;
784 this_inf->add_augmentation_size
785 = cie->cie_inf->add_augmentation_size;
787 ENSURE_NO_RELOCS (buf);
788 if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
792 REQUIRE (GET_RELOC (buf));
794 /* Chain together the FDEs for each section. */
795 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
796 /* RSEC will be NULL if FDE was cleared out as it was belonging to
797 a discarded SHT_GROUP. */
800 REQUIRE (rsec->owner == abfd);
801 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
802 elf_fde_list (rsec) = this_inf;
806 /* Skip the initial location and address range. */
808 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
809 REQUIRE (skip_bytes (&buf, end, 2 * length));
811 SKIP_RELOCS (buf - length);
812 if (!GET_RELOC (buf - length)
813 && read_value (abfd, buf - length, length, FALSE) == 0)
815 (*info->callbacks->minfo)
816 (_("discarding zero address range FDE in %B(%A).\n"),
818 this_inf->u.fde.cie_inf = NULL;
821 /* Skip the augmentation size, if present. */
822 if (cie->augmentation[0] == 'z')
823 REQUIRE (read_uleb128 (&buf, end, &length));
827 /* Of the supported augmentation characters above, only 'L'
828 adds augmentation data to the FDE. This code would need to
829 be adjusted if any future augmentations do the same thing. */
830 if (cie->lsda_encoding != DW_EH_PE_omit)
833 if (cie->can_make_lsda_relative && GET_RELOC (buf))
834 cie->cie_inf->u.cie.make_lsda_relative = 1;
835 this_inf->lsda_offset = buf - start;
836 /* If there's no 'z' augmentation, we don't know where the
837 CFA insns begin. Assume no padding. */
838 if (cie->augmentation[0] != 'z')
842 /* Skip over the augmentation data. */
843 REQUIRE (skip_bytes (&buf, end, length));
846 buf = last_fde + 4 + hdr_length;
848 /* For NULL RSEC (cleared FDE belonging to a discarded section)
849 the relocations are commonly cleared. We do not sanity check if
850 all these relocations are cleared as (1) relocations to
851 .gcc_except_table will remain uncleared (they will get dropped
852 with the drop of this unused FDE) and (2) BFD already safely drops
853 relocations of any type to .eh_frame by
854 elf_section_ignore_discarded_relocs.
855 TODO: The .gcc_except_table entries should be also filtered as
856 .eh_frame entries; or GCC could rather use COMDAT for them. */
860 /* Try to interpret the CFA instructions and find the first
861 padding nop. Shrink this_inf's size so that it doesn't
862 include the padding. */
863 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
865 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
866 /* If we don't understand the CFA instructions, we can't know
867 what needs to be adjusted there. */
868 if (insns_end == NULL
869 /* For the time being we don't support DW_CFA_set_loc in
871 || (set_loc_count && this_inf->cie))
873 this_inf->size -= end - insns_end;
874 if (insns_end != end && this_inf->cie)
876 cie->initial_insn_length -= end - insns_end;
877 cie->length -= end - insns_end;
880 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
881 || this_inf->make_relative))
886 this_inf->set_loc = (unsigned int *)
887 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
888 REQUIRE (this_inf->set_loc);
889 this_inf->set_loc[0] = set_loc_count;
894 if (*p == DW_CFA_set_loc)
895 this_inf->set_loc[++cnt] = p + 1 - start;
896 REQUIRE (skip_cfa_op (&p, end, length));
900 this_inf->removed = 1;
901 this_inf->fde_encoding = cie->fde_encoding;
902 this_inf->lsda_encoding = cie->lsda_encoding;
905 BFD_ASSERT (sec_info->count == num_entries);
906 BFD_ASSERT (cie_count == num_cies);
908 elf_section_data (sec)->sec_info = sec_info;
909 sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
910 if (!info->relocatable)
912 /* Keep info for merging cies. */
913 sec_info->cies = local_cies;
919 (*info->callbacks->einfo)
920 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
922 hdr_info->table = FALSE;
933 /* Mark all relocations against CIE or FDE ENT, which occurs in
934 .eh_frame section SEC. COOKIE describes the relocations in SEC;
935 its "rel" field can be changed freely. */
938 mark_entry (struct bfd_link_info *info, asection *sec,
939 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
940 struct elf_reloc_cookie *cookie)
942 /* FIXME: octets_per_byte. */
943 for (cookie->rel = cookie->rels + ent->reloc_index;
944 cookie->rel < cookie->relend
945 && cookie->rel->r_offset < ent->offset + ent->size;
947 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
953 /* Mark all the relocations against FDEs that relate to code in input
954 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
955 relocations are described by COOKIE. */
958 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
959 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
960 struct elf_reloc_cookie *cookie)
962 struct eh_cie_fde *fde, *cie;
964 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
966 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
969 /* At this stage, all cie_inf fields point to local CIEs, so we
970 can use the same cookie to refer to them. */
971 cie = fde->u.fde.cie_inf;
972 if (cie != NULL && !cie->u.cie.gc_mark)
974 cie->u.cie.gc_mark = 1;
975 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
982 /* Input section SEC of ABFD is an .eh_frame section that contains the
983 CIE described by CIE_INF. Return a version of CIE_INF that is going
984 to be kept in the output, adding CIE_INF to the output if necessary.
986 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
987 relocations in REL. */
989 static struct eh_cie_fde *
990 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
991 struct eh_frame_hdr_info *hdr_info,
992 struct elf_reloc_cookie *cookie,
993 struct eh_cie_fde *cie_inf)
995 unsigned long r_symndx;
996 struct cie *cie, *new_cie;
997 Elf_Internal_Rela *rel;
1000 /* Use CIE_INF if we have already decided to keep it. */
1001 if (!cie_inf->removed)
1004 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1005 if (cie_inf->u.cie.merged)
1006 return cie_inf->u.cie.u.merged_with;
1008 cie = cie_inf->u.cie.u.full_cie;
1010 /* Assume we will need to keep CIE_INF. */
1011 cie_inf->removed = 0;
1012 cie_inf->u.cie.u.sec = sec;
1014 /* If we are not merging CIEs, use CIE_INF. */
1018 if (cie->per_encoding != DW_EH_PE_omit)
1020 bfd_boolean per_binds_local;
1022 /* Work out the address of personality routine, or at least
1023 enough info that we could calculate the address had we made a
1024 final section layout. The symbol on the reloc is enough,
1025 either the hash for a global, or (bfd id, index) pair for a
1026 local. The assumption here is that no one uses addends on
1028 rel = cookie->rels + cie->personality.reloc_index;
1029 memset (&cie->personality, 0, sizeof (cie->personality));
1031 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1032 r_symndx = ELF64_R_SYM (rel->r_info);
1035 r_symndx = ELF32_R_SYM (rel->r_info);
1036 if (r_symndx >= cookie->locsymcount
1037 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1039 struct elf_link_hash_entry *h;
1041 r_symndx -= cookie->extsymoff;
1042 h = cookie->sym_hashes[r_symndx];
1044 while (h->root.type == bfd_link_hash_indirect
1045 || h->root.type == bfd_link_hash_warning)
1046 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1048 cie->personality.h = h;
1049 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1053 Elf_Internal_Sym *sym;
1056 sym = &cookie->locsyms[r_symndx];
1057 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1058 if (sym_sec == NULL)
1061 if (sym_sec->kept_section != NULL)
1062 sym_sec = sym_sec->kept_section;
1063 if (sym_sec->output_section == NULL)
1066 cie->local_personality = 1;
1067 cie->personality.sym.bfd_id = abfd->id;
1068 cie->personality.sym.index = r_symndx;
1069 per_binds_local = TRUE;
1074 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1075 && (get_elf_backend_data (abfd)
1076 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1078 cie_inf->u.cie.make_per_encoding_relative = 1;
1079 cie_inf->u.cie.per_encoding_relative = 1;
1083 /* See if we can merge this CIE with an earlier one. */
1084 cie_compute_hash (cie);
1085 if (hdr_info->cies == NULL)
1087 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1088 if (hdr_info->cies == NULL)
1091 loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1095 new_cie = (struct cie *) *loc;
1096 if (new_cie == NULL)
1098 /* Keep CIE_INF and record it in the hash table. */
1099 new_cie = (struct cie *) malloc (sizeof (struct cie));
1100 if (new_cie == NULL)
1103 memcpy (new_cie, cie, sizeof (struct cie));
1108 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1109 cie_inf->removed = 1;
1110 cie_inf->u.cie.merged = 1;
1111 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1112 if (cie_inf->u.cie.make_lsda_relative)
1113 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1115 return new_cie->cie_inf;
1118 /* This function is called for each input file before the .eh_frame
1119 section is relocated. It discards duplicate CIEs and FDEs for discarded
1120 functions. The function returns TRUE iff any entries have been
1124 _bfd_elf_discard_section_eh_frame
1125 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1126 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1127 struct elf_reloc_cookie *cookie)
1129 struct eh_cie_fde *ent;
1130 struct eh_frame_sec_info *sec_info;
1131 struct eh_frame_hdr_info *hdr_info;
1132 unsigned int ptr_size, offset;
1134 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1137 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1138 if (sec_info == NULL)
1141 ptr_size = (get_elf_backend_data (sec->owner)
1142 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1144 hdr_info = &elf_hash_table (info)->eh_info;
1145 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1147 /* There should only be one zero terminator, on the last input
1148 file supplying .eh_frame (crtend.o). Remove any others. */
1149 ent->removed = sec->map_head.s != NULL;
1150 else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1153 if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1156 = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1158 = read_value (abfd, sec->contents + ent->offset + 8 + width,
1159 width, get_DW_EH_PE_signed (ent->fde_encoding));
1164 cookie->rel = cookie->rels + ent->reloc_index;
1165 /* FIXME: octets_per_byte. */
1166 BFD_ASSERT (cookie->rel < cookie->relend
1167 && cookie->rel->r_offset == ent->offset + 8);
1168 keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1173 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1174 && ent->make_relative == 0)
1175 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1177 /* If a shared library uses absolute pointers
1178 which we cannot turn into PC relative,
1179 don't create the binary search table,
1180 since it is affected by runtime relocations. */
1181 hdr_info->table = FALSE;
1182 (*info->callbacks->einfo)
1183 (_("%P: FDE encoding in %B(%A) prevents .eh_frame_hdr"
1184 " table being created.\n"), abfd, sec);
1187 hdr_info->fde_count++;
1188 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1189 cookie, ent->u.fde.cie_inf);
1195 free (sec_info->cies);
1196 sec_info->cies = NULL;
1200 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1203 ent->new_offset = offset;
1204 offset += size_of_output_cie_fde (ent, ptr_size);
1207 sec->rawsize = sec->size;
1209 return offset != sec->rawsize;
1212 /* This function is called for .eh_frame_hdr section after
1213 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1214 input sections. It finalizes the size of .eh_frame_hdr section. */
1217 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1219 struct elf_link_hash_table *htab;
1220 struct eh_frame_hdr_info *hdr_info;
1223 htab = elf_hash_table (info);
1224 hdr_info = &htab->eh_info;
1226 if (hdr_info->cies != NULL)
1228 htab_delete (hdr_info->cies);
1229 hdr_info->cies = NULL;
1232 sec = hdr_info->hdr_sec;
1236 sec->size = EH_FRAME_HDR_SIZE;
1237 if (hdr_info->table)
1238 sec->size += 4 + hdr_info->fde_count * 8;
1240 elf_eh_frame_hdr (abfd) = sec;
1244 /* Return true if there is at least one non-empty .eh_frame section in
1245 input files. Can only be called after ld has mapped input to
1246 output sections, and before sections are stripped. */
1248 _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1250 asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1255 /* Count only sections which have at least a single CIE or FDE.
1256 There cannot be any CIE or FDE <= 8 bytes. */
1257 for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1264 /* This function is called from size_dynamic_sections.
1265 It needs to decide whether .eh_frame_hdr should be output or not,
1266 because when the dynamic symbol table has been sized it is too late
1267 to strip sections. */
1270 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1272 struct elf_link_hash_table *htab;
1273 struct eh_frame_hdr_info *hdr_info;
1275 htab = elf_hash_table (info);
1276 hdr_info = &htab->eh_info;
1277 if (hdr_info->hdr_sec == NULL)
1280 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1281 || !info->eh_frame_hdr
1282 || !_bfd_elf_eh_frame_present (info))
1284 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1285 hdr_info->hdr_sec = NULL;
1289 hdr_info->table = TRUE;
1293 /* Adjust an address in the .eh_frame section. Given OFFSET within
1294 SEC, this returns the new offset in the adjusted .eh_frame section,
1295 or -1 if the address refers to a CIE/FDE which has been removed
1296 or to offset with dynamic relocation which is no longer needed. */
1299 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1300 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1304 struct eh_frame_sec_info *sec_info;
1305 unsigned int lo, hi, mid;
1307 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1309 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1311 if (offset >= sec->rawsize)
1312 return offset - sec->rawsize + sec->size;
1315 hi = sec_info->count;
1319 mid = (lo + hi) / 2;
1320 if (offset < sec_info->entry[mid].offset)
1323 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1329 BFD_ASSERT (lo < hi);
1331 /* FDE or CIE was removed. */
1332 if (sec_info->entry[mid].removed)
1333 return (bfd_vma) -1;
1335 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1336 no need for run-time relocation against the personality field. */
1337 if (sec_info->entry[mid].cie
1338 && sec_info->entry[mid].u.cie.make_per_encoding_relative
1339 && offset == (sec_info->entry[mid].offset + 8
1340 + sec_info->entry[mid].u.cie.personality_offset))
1341 return (bfd_vma) -2;
1343 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1344 relocation against FDE's initial_location field. */
1345 if (!sec_info->entry[mid].cie
1346 && sec_info->entry[mid].make_relative
1347 && offset == sec_info->entry[mid].offset + 8)
1348 return (bfd_vma) -2;
1350 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1351 for run-time relocation against LSDA field. */
1352 if (!sec_info->entry[mid].cie
1353 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1354 && offset == (sec_info->entry[mid].offset + 8
1355 + sec_info->entry[mid].lsda_offset))
1356 return (bfd_vma) -2;
1358 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1359 relocation against DW_CFA_set_loc's arguments. */
1360 if (sec_info->entry[mid].set_loc
1361 && sec_info->entry[mid].make_relative
1362 && (offset >= sec_info->entry[mid].offset + 8
1363 + sec_info->entry[mid].set_loc[1]))
1367 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1368 if (offset == sec_info->entry[mid].offset + 8
1369 + sec_info->entry[mid].set_loc[cnt])
1370 return (bfd_vma) -2;
1373 /* Any new augmentation bytes go before the first relocation. */
1374 return (offset + sec_info->entry[mid].new_offset
1375 - sec_info->entry[mid].offset
1376 + extra_augmentation_string_bytes (sec_info->entry + mid)
1377 + extra_augmentation_data_bytes (sec_info->entry + mid));
1380 /* Write out .eh_frame section. This is called with the relocated
1384 _bfd_elf_write_section_eh_frame (bfd *abfd,
1385 struct bfd_link_info *info,
1389 struct eh_frame_sec_info *sec_info;
1390 struct elf_link_hash_table *htab;
1391 struct eh_frame_hdr_info *hdr_info;
1392 unsigned int ptr_size;
1393 struct eh_cie_fde *ent;
1395 if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1396 /* FIXME: octets_per_byte. */
1397 return bfd_set_section_contents (abfd, sec->output_section, contents,
1398 sec->output_offset, sec->size);
1400 ptr_size = (get_elf_backend_data (abfd)
1401 ->elf_backend_eh_frame_address_size (abfd, sec));
1402 BFD_ASSERT (ptr_size != 0);
1404 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1405 htab = elf_hash_table (info);
1406 hdr_info = &htab->eh_info;
1408 if (hdr_info->table && hdr_info->array == NULL)
1409 hdr_info->array = (struct eh_frame_array_ent *)
1410 bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1411 if (hdr_info->array == NULL)
1414 /* The new offsets can be bigger or smaller than the original offsets.
1415 We therefore need to make two passes over the section: one backward
1416 pass to move entries up and one forward pass to move entries down.
1417 The two passes won't interfere with each other because entries are
1419 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1420 if (!ent->removed && ent->new_offset > ent->offset)
1421 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1423 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1424 if (!ent->removed && ent->new_offset < ent->offset)
1425 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1427 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1429 unsigned char *buf, *end;
1430 unsigned int new_size;
1437 /* Any terminating FDE must be at the end of the section. */
1438 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1442 buf = contents + ent->new_offset;
1443 end = buf + ent->size;
1444 new_size = size_of_output_cie_fde (ent, ptr_size);
1446 /* Update the size. It may be shrinked. */
1447 bfd_put_32 (abfd, new_size - 4, buf);
1449 /* Filling the extra bytes with DW_CFA_nops. */
1450 if (new_size != ent->size)
1451 memset (end, 0, new_size - ent->size);
1456 if (ent->make_relative
1457 || ent->u.cie.make_lsda_relative
1458 || ent->u.cie.per_encoding_relative)
1461 unsigned int action, extra_string, extra_data;
1462 unsigned int per_width, per_encoding;
1464 /* Need to find 'R' or 'L' augmentation's argument and modify
1465 DW_EH_PE_* value. */
1466 action = ((ent->make_relative ? 1 : 0)
1467 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1468 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1469 extra_string = extra_augmentation_string_bytes (ent);
1470 extra_data = extra_augmentation_data_bytes (ent);
1472 /* Skip length, id and version. */
1475 buf += strlen (aug) + 1;
1476 skip_leb128 (&buf, end);
1477 skip_leb128 (&buf, end);
1478 skip_leb128 (&buf, end);
1481 /* The uleb128 will always be a single byte for the kind
1482 of augmentation strings that we're prepared to handle. */
1483 *buf++ += extra_data;
1487 /* Make room for the new augmentation string and data bytes. */
1488 memmove (buf + extra_string + extra_data, buf, end - buf);
1489 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1490 buf += extra_string;
1491 end += extra_string + extra_data;
1493 if (ent->add_augmentation_size)
1496 *buf++ = extra_data - 1;
1498 if (ent->u.cie.add_fde_encoding)
1500 BFD_ASSERT (action & 1);
1502 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1512 BFD_ASSERT (*buf == ent->lsda_encoding);
1513 *buf = make_pc_relative (*buf, ptr_size);
1519 if (ent->u.cie.make_per_encoding_relative)
1520 *buf = make_pc_relative (*buf, ptr_size);
1521 per_encoding = *buf++;
1522 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1523 BFD_ASSERT (per_width != 0);
1524 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1525 == ent->u.cie.per_encoding_relative);
1526 if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1528 + ((buf - contents + per_width - 1)
1529 & ~((bfd_size_type) per_width - 1)));
1534 val = read_value (abfd, buf, per_width,
1535 get_DW_EH_PE_signed (per_encoding));
1536 if (ent->u.cie.make_per_encoding_relative)
1537 val -= (sec->output_section->vma
1538 + sec->output_offset
1539 + (buf - contents));
1542 val += (bfd_vma) ent->offset - ent->new_offset;
1543 val -= extra_string + extra_data;
1545 write_value (abfd, buf, val, per_width);
1553 BFD_ASSERT (*buf == ent->fde_encoding);
1554 *buf = make_pc_relative (*buf, ptr_size);
1569 bfd_vma value, address;
1572 struct eh_cie_fde *cie;
1575 cie = ent->u.fde.cie_inf;
1577 value = ((ent->new_offset + sec->output_offset + 4)
1578 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1579 bfd_put_32 (abfd, value, buf);
1581 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1582 value = read_value (abfd, buf, width,
1583 get_DW_EH_PE_signed (ent->fde_encoding));
1587 switch (ent->fde_encoding & 0x70)
1589 case DW_EH_PE_textrel:
1590 BFD_ASSERT (hdr_info == NULL);
1592 case DW_EH_PE_datarel:
1594 switch (abfd->arch_info->arch)
1597 BFD_ASSERT (elf_gp (abfd) != 0);
1598 address += elf_gp (abfd);
1601 (*info->callbacks->einfo)
1602 (_("%P: DW_EH_PE_datarel unspecified"
1603 " for this architecture.\n"));
1607 BFD_ASSERT (htab->hgot != NULL
1608 && ((htab->hgot->root.type
1609 == bfd_link_hash_defined)
1610 || (htab->hgot->root.type
1611 == bfd_link_hash_defweak)));
1613 += (htab->hgot->root.u.def.value
1614 + htab->hgot->root.u.def.section->output_offset
1615 + (htab->hgot->root.u.def.section->output_section
1621 case DW_EH_PE_pcrel:
1622 value += (bfd_vma) ent->offset - ent->new_offset;
1623 address += (sec->output_section->vma
1624 + sec->output_offset
1628 if (ent->make_relative)
1629 value -= (sec->output_section->vma
1630 + sec->output_offset
1631 + ent->new_offset + 8);
1632 write_value (abfd, buf, value, width);
1639 /* The address calculation may overflow, giving us a
1640 value greater than 4G on a 32-bit target when
1641 dwarf_vma is 64-bit. */
1642 if (sizeof (address) > 4 && ptr_size == 4)
1643 address &= 0xffffffff;
1644 hdr_info->array[hdr_info->array_count].initial_loc = address;
1645 hdr_info->array[hdr_info->array_count].range
1646 = read_value (abfd, buf + width, width, FALSE);
1647 hdr_info->array[hdr_info->array_count++].fde
1648 = (sec->output_section->vma
1649 + sec->output_offset
1653 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1654 || cie->u.cie.make_lsda_relative)
1656 buf += ent->lsda_offset;
1657 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1658 value = read_value (abfd, buf, width,
1659 get_DW_EH_PE_signed (ent->lsda_encoding));
1662 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1663 value += (bfd_vma) ent->offset - ent->new_offset;
1664 else if (cie->u.cie.make_lsda_relative)
1665 value -= (sec->output_section->vma
1666 + sec->output_offset
1667 + ent->new_offset + 8 + ent->lsda_offset);
1668 write_value (abfd, buf, value, width);
1671 else if (ent->add_augmentation_size)
1673 /* Skip the PC and length and insert a zero byte for the
1674 augmentation size. */
1676 memmove (buf + 1, buf, end - buf);
1682 /* Adjust DW_CFA_set_loc. */
1686 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1687 new_offset = ent->new_offset + 8
1688 + extra_augmentation_string_bytes (ent)
1689 + extra_augmentation_data_bytes (ent);
1691 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1693 buf = start + ent->set_loc[cnt];
1695 value = read_value (abfd, buf, width,
1696 get_DW_EH_PE_signed (ent->fde_encoding));
1700 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1701 value += (bfd_vma) ent->offset + 8 - new_offset;
1702 if (ent->make_relative)
1703 value -= (sec->output_section->vma
1704 + sec->output_offset
1705 + new_offset + ent->set_loc[cnt]);
1706 write_value (abfd, buf, value, width);
1712 /* We don't align the section to its section alignment since the
1713 runtime library only expects all CIE/FDE records aligned at
1714 the pointer size. _bfd_elf_discard_section_eh_frame should
1715 have padded CIE/FDE records to multiple of pointer size with
1716 size_of_output_cie_fde. */
1717 if ((sec->size % ptr_size) != 0)
1720 /* FIXME: octets_per_byte. */
1721 return bfd_set_section_contents (abfd, sec->output_section,
1722 contents, (file_ptr) sec->output_offset,
1726 /* Helper function used to sort .eh_frame_hdr search table by increasing
1727 VMA of FDE initial location. */
1730 vma_compare (const void *a, const void *b)
1732 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1733 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1734 if (p->initial_loc > q->initial_loc)
1736 if (p->initial_loc < q->initial_loc)
1738 if (p->range > q->range)
1740 if (p->range < q->range)
1745 /* Write out .eh_frame_hdr section. This must be called after
1746 _bfd_elf_write_section_eh_frame has been called on all input
1748 .eh_frame_hdr format:
1749 ubyte version (currently 1)
1750 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1752 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1753 number (or DW_EH_PE_omit if there is no
1754 binary search table computed))
1755 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1756 or DW_EH_PE_omit if not present.
1757 DW_EH_PE_datarel is using address of
1758 .eh_frame_hdr section start as base)
1759 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1760 optionally followed by:
1761 [encoded] fde_count (total number of FDEs in .eh_frame section)
1762 fde_count x [encoded] initial_loc, fde
1763 (array of encoded pairs containing
1764 FDE initial_location field and FDE address,
1765 sorted by increasing initial_loc). */
1768 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1770 struct elf_link_hash_table *htab;
1771 struct eh_frame_hdr_info *hdr_info;
1773 bfd_boolean retval = TRUE;
1775 htab = elf_hash_table (info);
1776 hdr_info = &htab->eh_info;
1777 sec = hdr_info->hdr_sec;
1779 if (info->eh_frame_hdr && sec != NULL)
1782 asection *eh_frame_sec;
1784 bfd_vma encoded_eh_frame;
1786 size = EH_FRAME_HDR_SIZE;
1787 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1788 size += 4 + hdr_info->fde_count * 8;
1789 contents = (bfd_byte *) bfd_malloc (size);
1790 if (contents == NULL)
1793 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1794 if (eh_frame_sec == NULL)
1800 memset (contents, 0, EH_FRAME_HDR_SIZE);
1803 /* .eh_frame offset. */
1804 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1805 (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
1807 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1809 /* FDE count encoding. */
1810 contents[2] = DW_EH_PE_udata4;
1811 /* Search table encoding. */
1812 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
1816 contents[2] = DW_EH_PE_omit;
1817 contents[3] = DW_EH_PE_omit;
1819 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1821 if (contents[2] != DW_EH_PE_omit)
1825 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1826 qsort (hdr_info->array, hdr_info->fde_count,
1827 sizeof (*hdr_info->array), vma_compare);
1828 for (i = 0; i < hdr_info->fde_count; i++)
1832 val = hdr_info->array[i].initial_loc - sec->output_section->vma;
1833 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1834 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
1835 && (hdr_info->array[i].initial_loc
1836 != sec->output_section->vma + val))
1837 (*info->callbacks->einfo)
1838 (_("%X%P: .eh_frame_hdr table[%u] PC overflow.\n"), i);
1839 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1841 val = hdr_info->array[i].fde - sec->output_section->vma;
1842 val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
1843 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
1844 && (hdr_info->array[i].fde
1845 != sec->output_section->vma + val))
1846 (*info->callbacks->einfo)
1847 (_("%X%P: .eh_frame_hdr table[%u] FDE overflow.\n"), i);
1848 bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1851 && (hdr_info->array[i].initial_loc
1852 < (hdr_info->array[i - 1].initial_loc
1853 + hdr_info->array[i - 1].range)))
1854 (*info->callbacks->einfo)
1855 (_("%X%P: .eh_frame_hdr table[%u] FDE at %V overlaps "
1856 "table[%u] FDE at %V.\n"),
1857 i - 1, hdr_info->array[i - 1].fde,
1858 i, hdr_info->array[i].fde);
1862 /* FIXME: octets_per_byte. */
1863 if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1864 (file_ptr) sec->output_offset,
1869 if (hdr_info->array != NULL)
1870 free (hdr_info->array);
1874 /* Return the width of FDE addresses. This is the default implementation. */
1877 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1879 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1882 /* Decide whether we can use a PC-relative encoding within the given
1883 EH frame section. This is the default implementation. */
1886 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1887 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1888 asection *eh_frame_section ATTRIBUTE_UNUSED)
1893 /* Select an encoding for the given address. Preference is given to
1894 PC-relative addressing modes. */
1897 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1898 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1899 asection *osec, bfd_vma offset,
1900 asection *loc_sec, bfd_vma loc_offset,
1903 *encoded = osec->vma + offset -
1904 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1905 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;