1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Written by Jakub Jelinek <jakub@redhat.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
29 #define EH_FRAME_HDR_SIZE 8
35 unsigned char version;
36 unsigned char local_personality;
37 char augmentation[20];
39 bfd_signed_vma data_align;
41 bfd_vma augmentation_size;
43 struct elf_link_hash_entry *h;
45 unsigned int reloc_index;
48 struct eh_cie_fde *cie_inf;
49 unsigned char per_encoding;
50 unsigned char lsda_encoding;
51 unsigned char fde_encoding;
52 unsigned char initial_insn_length;
53 unsigned char can_make_lsda_relative;
54 unsigned char initial_instructions[50];
59 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
60 move onto the next byte. Return true on success. */
62 static inline bfd_boolean
63 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
67 *result = *((*iter)++);
71 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
72 Return true it was possible to move LENGTH bytes. */
74 static inline bfd_boolean
75 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
77 if ((bfd_size_type) (end - *iter) < length)
86 /* Move *ITER over an leb128, stopping at END. Return true if the end
87 of the leb128 was found. */
90 skip_leb128 (bfd_byte **iter, bfd_byte *end)
94 if (!read_byte (iter, end, &byte))
100 /* Like skip_leb128, but treat the leb128 as an unsigned value and
101 store it in *VALUE. */
104 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
109 if (!skip_leb128 (iter, end))
115 *value = (*value << 7) | (*--p & 0x7f);
120 /* Like read_uleb128, but for signed values. */
123 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
128 if (!skip_leb128 (iter, end))
132 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
134 *value = (*value << 7) | (*--p & 0x7f);
139 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
142 int get_DW_EH_PE_width (int encoding, int ptr_size)
144 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
146 if ((encoding & 0x60) == 0x60)
149 switch (encoding & 7)
151 case DW_EH_PE_udata2: return 2;
152 case DW_EH_PE_udata4: return 4;
153 case DW_EH_PE_udata8: return 8;
154 case DW_EH_PE_absptr: return ptr_size;
162 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164 /* Read a width sized value from memory. */
167 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
175 value = bfd_get_signed_16 (abfd, buf);
177 value = bfd_get_16 (abfd, buf);
181 value = bfd_get_signed_32 (abfd, buf);
183 value = bfd_get_32 (abfd, buf);
187 value = bfd_get_signed_64 (abfd, buf);
189 value = bfd_get_64 (abfd, buf);
199 /* Store a width sized value to memory. */
202 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
206 case 2: bfd_put_16 (abfd, value, buf); break;
207 case 4: bfd_put_32 (abfd, value, buf); break;
208 case 8: bfd_put_64 (abfd, value, buf); break;
209 default: BFD_FAIL ();
213 /* Return one if C1 and C2 CIEs can be merged. */
216 cie_eq (const void *e1, const void *e2)
218 const struct cie *c1 = (const struct cie *) e1;
219 const struct cie *c2 = (const struct cie *) e2;
221 if (c1->hash == c2->hash
222 && c1->length == c2->length
223 && c1->version == c2->version
224 && c1->local_personality == c2->local_personality
225 && strcmp (c1->augmentation, c2->augmentation) == 0
226 && strcmp (c1->augmentation, "eh") != 0
227 && c1->code_align == c2->code_align
228 && c1->data_align == c2->data_align
229 && c1->ra_column == c2->ra_column
230 && c1->augmentation_size == c2->augmentation_size
231 && memcmp (&c1->personality, &c2->personality,
232 sizeof (c1->personality)) == 0
233 && c1->output_sec == c2->output_sec
234 && c1->per_encoding == c2->per_encoding
235 && c1->lsda_encoding == c2->lsda_encoding
236 && c1->fde_encoding == c2->fde_encoding
237 && c1->initial_insn_length == c2->initial_insn_length
238 && memcmp (c1->initial_instructions,
239 c2->initial_instructions,
240 c1->initial_insn_length) == 0)
247 cie_hash (const void *e)
249 const struct cie *c = (const struct cie *) e;
254 cie_compute_hash (struct cie *c)
257 h = iterative_hash_object (c->length, h);
258 h = iterative_hash_object (c->version, h);
259 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
260 h = iterative_hash_object (c->code_align, h);
261 h = iterative_hash_object (c->data_align, h);
262 h = iterative_hash_object (c->ra_column, h);
263 h = iterative_hash_object (c->augmentation_size, h);
264 h = iterative_hash_object (c->personality, h);
265 h = iterative_hash_object (c->output_sec, h);
266 h = iterative_hash_object (c->per_encoding, h);
267 h = iterative_hash_object (c->lsda_encoding, h);
268 h = iterative_hash_object (c->fde_encoding, h);
269 h = iterative_hash_object (c->initial_insn_length, h);
270 h = iterative_hash (c->initial_instructions, c->initial_insn_length, h);
275 /* Return the number of extra bytes that we'll be inserting into
276 ENTRY's augmentation string. */
278 static INLINE unsigned int
279 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
281 unsigned int size = 0;
284 if (entry->add_augmentation_size)
286 if (entry->u.cie.add_fde_encoding)
292 /* Likewise ENTRY's augmentation data. */
294 static INLINE unsigned int
295 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
297 unsigned int size = 0;
298 if (entry->add_augmentation_size)
300 if (entry->cie && entry->u.cie.add_fde_encoding)
305 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
306 required alignment of ENTRY in bytes. */
309 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
313 if (entry->size == 4)
316 + extra_augmentation_string_bytes (entry)
317 + extra_augmentation_data_bytes (entry)
318 + alignment - 1) & -alignment;
321 /* Assume that the bytes between *ITER and END are CFA instructions.
322 Try to move *ITER past the first instruction and return true on
323 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
326 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
331 if (!read_byte (iter, end, &op))
334 switch (op & 0xc0 ? op & 0xc0 : op)
337 case DW_CFA_advance_loc:
339 case DW_CFA_remember_state:
340 case DW_CFA_restore_state:
341 case DW_CFA_GNU_window_save:
346 case DW_CFA_restore_extended:
347 case DW_CFA_undefined:
348 case DW_CFA_same_value:
349 case DW_CFA_def_cfa_register:
350 case DW_CFA_def_cfa_offset:
351 case DW_CFA_def_cfa_offset_sf:
352 case DW_CFA_GNU_args_size:
353 /* One leb128 argument. */
354 return skip_leb128 (iter, end);
356 case DW_CFA_val_offset:
357 case DW_CFA_val_offset_sf:
358 case DW_CFA_offset_extended:
359 case DW_CFA_register:
361 case DW_CFA_offset_extended_sf:
362 case DW_CFA_GNU_negative_offset_extended:
363 case DW_CFA_def_cfa_sf:
364 /* Two leb128 arguments. */
365 return (skip_leb128 (iter, end)
366 && skip_leb128 (iter, end));
368 case DW_CFA_def_cfa_expression:
369 /* A variable-length argument. */
370 return (read_uleb128 (iter, end, &length)
371 && skip_bytes (iter, end, length));
373 case DW_CFA_expression:
374 case DW_CFA_val_expression:
375 /* A leb128 followed by a variable-length argument. */
376 return (skip_leb128 (iter, end)
377 && read_uleb128 (iter, end, &length)
378 && skip_bytes (iter, end, length));
381 return skip_bytes (iter, end, encoded_ptr_width);
383 case DW_CFA_advance_loc1:
384 return skip_bytes (iter, end, 1);
386 case DW_CFA_advance_loc2:
387 return skip_bytes (iter, end, 2);
389 case DW_CFA_advance_loc4:
390 return skip_bytes (iter, end, 4);
392 case DW_CFA_MIPS_advance_loc8:
393 return skip_bytes (iter, end, 8);
400 /* Try to interpret the bytes between BUF and END as CFA instructions.
401 If every byte makes sense, return a pointer to the first DW_CFA_nop
402 padding byte, or END if there is no padding. Return null otherwise.
403 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
406 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
407 unsigned int *set_loc_count)
413 if (*buf == DW_CFA_nop)
417 if (*buf == DW_CFA_set_loc)
419 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
426 /* Convert absolute encoding ENCODING into PC-relative form.
427 SIZE is the size of a pointer. */
430 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
432 if ((encoding & 0x7f) == DW_EH_PE_absptr)
436 encoding |= DW_EH_PE_sdata2;
439 encoding |= DW_EH_PE_sdata4;
442 encoding |= DW_EH_PE_sdata8;
445 return encoding | DW_EH_PE_pcrel;
448 /* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
449 .eh_frame section. */
452 _bfd_elf_begin_eh_frame_parsing (struct bfd_link_info *info)
454 struct eh_frame_hdr_info *hdr_info;
456 hdr_info = &elf_hash_table (info)->eh_info;
457 hdr_info->merge_cies = !info->relocatable;
460 /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
461 information in the section's sec_info field on success. COOKIE
462 describes the relocations in SEC. */
465 _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
466 asection *sec, struct elf_reloc_cookie *cookie)
468 #define REQUIRE(COND) \
471 goto free_no_table; \
474 bfd_byte *ehbuf = NULL, *buf, *end;
476 struct eh_cie_fde *this_inf;
477 unsigned int hdr_length, hdr_id;
478 unsigned int cie_count;
479 struct cie *cie, *local_cies = NULL;
480 struct elf_link_hash_table *htab;
481 struct eh_frame_hdr_info *hdr_info;
482 struct eh_frame_sec_info *sec_info = NULL;
483 unsigned int ptr_size;
484 unsigned int num_cies;
485 unsigned int num_entries;
486 elf_gc_mark_hook_fn gc_mark_hook;
488 htab = elf_hash_table (info);
489 hdr_info = &htab->eh_info;
490 if (hdr_info->parsed_eh_frames)
495 /* This file does not contain .eh_frame information. */
499 if (bfd_is_abs_section (sec->output_section))
501 /* At least one of the sections is being discarded from the
502 link, so we should just ignore them. */
506 /* Read the frame unwind information from abfd. */
508 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
511 && bfd_get_32 (abfd, ehbuf) == 0
512 && cookie->rel == cookie->relend)
514 /* Empty .eh_frame section. */
519 /* If .eh_frame section size doesn't fit into int, we cannot handle
520 it (it would need to use 64-bit .eh_frame format anyway). */
521 REQUIRE (sec->size == (unsigned int) sec->size);
523 ptr_size = (get_elf_backend_data (abfd)
524 ->elf_backend_eh_frame_address_size (abfd, sec));
525 REQUIRE (ptr_size != 0);
527 /* Go through the section contents and work out how many FDEs and
530 end = ehbuf + sec->size;
537 /* Read the length of the entry. */
538 REQUIRE (skip_bytes (&buf, end, 4));
539 hdr_length = bfd_get_32 (abfd, buf - 4);
541 /* 64-bit .eh_frame is not supported. */
542 REQUIRE (hdr_length != 0xffffffff);
546 REQUIRE (skip_bytes (&buf, end, 4));
547 hdr_id = bfd_get_32 (abfd, buf - 4);
551 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
554 sec_info = (struct eh_frame_sec_info *)
555 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
556 + (num_entries - 1) * sizeof (struct eh_cie_fde));
559 /* We need to have a "struct cie" for each CIE in this section. */
560 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
561 REQUIRE (local_cies);
563 /* FIXME: octets_per_byte. */
564 #define ENSURE_NO_RELOCS(buf) \
565 REQUIRE (!(cookie->rel < cookie->relend \
566 && (cookie->rel->r_offset \
567 < (bfd_size_type) ((buf) - ehbuf)) \
568 && cookie->rel->r_info != 0))
570 /* FIXME: octets_per_byte. */
571 #define SKIP_RELOCS(buf) \
572 while (cookie->rel < cookie->relend \
573 && (cookie->rel->r_offset \
574 < (bfd_size_type) ((buf) - ehbuf))) \
577 /* FIXME: octets_per_byte. */
578 #define GET_RELOC(buf) \
579 ((cookie->rel < cookie->relend \
580 && (cookie->rel->r_offset \
581 == (bfd_size_type) ((buf) - ehbuf))) \
582 ? cookie->rel : NULL)
586 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
587 while ((bfd_size_type) (buf - ehbuf) != sec->size)
590 bfd_byte *start, *insns, *insns_end;
591 bfd_size_type length;
592 unsigned int set_loc_count;
594 this_inf = sec_info->entry + sec_info->count;
597 /* Read the length of the entry. */
598 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
599 hdr_length = bfd_get_32 (abfd, buf - 4);
601 /* The CIE/FDE must be fully contained in this input section. */
602 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
603 end = buf + hdr_length;
605 this_inf->offset = last_fde - ehbuf;
606 this_inf->size = 4 + hdr_length;
607 this_inf->reloc_index = cookie->rel - cookie->rels;
611 /* A zero-length CIE should only be found at the end of
613 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
614 ENSURE_NO_RELOCS (buf);
619 REQUIRE (skip_bytes (&buf, end, 4));
620 hdr_id = bfd_get_32 (abfd, buf - 4);
624 unsigned int initial_insn_length;
629 /* Point CIE to one of the section-local cie structures. */
630 cie = local_cies + cie_count++;
632 cie->cie_inf = this_inf;
633 cie->length = hdr_length;
634 cie->output_sec = sec->output_section;
636 REQUIRE (read_byte (&buf, end, &cie->version));
638 /* Cannot handle unknown versions. */
639 REQUIRE (cie->version == 1
641 || cie->version == 4);
642 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
644 strcpy (cie->augmentation, (char *) buf);
645 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
646 ENSURE_NO_RELOCS (buf);
647 if (buf[0] == 'e' && buf[1] == 'h')
649 /* GCC < 3.0 .eh_frame CIE */
650 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
651 is private to each CIE, so we don't need it for anything.
653 REQUIRE (skip_bytes (&buf, end, ptr_size));
656 if (cie->version >= 4)
658 REQUIRE (buf + 1 < end);
659 REQUIRE (buf[0] == ptr_size);
660 REQUIRE (buf[1] == 0);
663 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
664 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
665 if (cie->version == 1)
668 cie->ra_column = *buf++;
671 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
672 ENSURE_NO_RELOCS (buf);
673 cie->lsda_encoding = DW_EH_PE_omit;
674 cie->fde_encoding = DW_EH_PE_omit;
675 cie->per_encoding = DW_EH_PE_omit;
676 aug = cie->augmentation;
677 if (aug[0] != 'e' || aug[1] != 'h')
682 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
683 ENSURE_NO_RELOCS (buf);
690 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
691 ENSURE_NO_RELOCS (buf);
692 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
695 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
696 ENSURE_NO_RELOCS (buf);
697 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
705 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
706 per_width = get_DW_EH_PE_width (cie->per_encoding,
709 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
711 length = -(buf - ehbuf) & (per_width - 1);
712 REQUIRE (skip_bytes (&buf, end, length));
714 this_inf->u.cie.personality_offset = buf - start;
715 ENSURE_NO_RELOCS (buf);
716 /* Ensure we have a reloc here. */
717 REQUIRE (GET_RELOC (buf));
718 cie->personality.reloc_index
719 = cookie->rel - cookie->rels;
720 /* Cope with MIPS-style composite relocations. */
723 while (GET_RELOC (buf) != NULL);
724 REQUIRE (skip_bytes (&buf, end, per_width));
728 /* Unrecognized augmentation. Better bail out. */
733 /* For shared libraries, try to get rid of as many RELATIVE relocs
736 && (get_elf_backend_data (abfd)
737 ->elf_backend_can_make_relative_eh_frame
740 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
741 this_inf->make_relative = 1;
742 /* If the CIE doesn't already have an 'R' entry, it's fairly
743 easy to add one, provided that there's no aligned data
744 after the augmentation string. */
745 else if (cie->fde_encoding == DW_EH_PE_omit
746 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
748 if (*cie->augmentation == 0)
749 this_inf->add_augmentation_size = 1;
750 this_inf->u.cie.add_fde_encoding = 1;
751 this_inf->make_relative = 1;
754 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
755 cie->can_make_lsda_relative = 1;
758 /* If FDE encoding was not specified, it defaults to
760 if (cie->fde_encoding == DW_EH_PE_omit)
761 cie->fde_encoding = DW_EH_PE_absptr;
763 initial_insn_length = end - buf;
764 if (initial_insn_length <= sizeof (cie->initial_instructions))
766 cie->initial_insn_length = initial_insn_length;
767 memcpy (cie->initial_instructions, buf, initial_insn_length);
770 buf += initial_insn_length;
771 ENSURE_NO_RELOCS (buf);
773 if (hdr_info->merge_cies)
774 this_inf->u.cie.u.full_cie = cie;
775 this_inf->u.cie.per_encoding_relative
776 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
782 /* Find the corresponding CIE. */
783 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
784 for (cie = local_cies; cie < local_cies + cie_count; cie++)
785 if (cie_offset == cie->cie_inf->offset)
788 /* Ensure this FDE references one of the CIEs in this input
790 REQUIRE (cie != local_cies + cie_count);
791 this_inf->u.fde.cie_inf = cie->cie_inf;
792 this_inf->make_relative = cie->cie_inf->make_relative;
793 this_inf->add_augmentation_size
794 = cie->cie_inf->add_augmentation_size;
796 ENSURE_NO_RELOCS (buf);
797 REQUIRE (GET_RELOC (buf));
799 /* Chain together the FDEs for each section. */
800 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
801 /* RSEC will be NULL if FDE was cleared out as it was belonging to
802 a discarded SHT_GROUP. */
805 REQUIRE (rsec->owner == abfd);
806 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
807 elf_fde_list (rsec) = this_inf;
810 /* Skip the initial location and address range. */
812 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
813 REQUIRE (skip_bytes (&buf, end, 2 * length));
815 /* Skip the augmentation size, if present. */
816 if (cie->augmentation[0] == 'z')
817 REQUIRE (read_uleb128 (&buf, end, &length));
821 /* Of the supported augmentation characters above, only 'L'
822 adds augmentation data to the FDE. This code would need to
823 be adjusted if any future augmentations do the same thing. */
824 if (cie->lsda_encoding != DW_EH_PE_omit)
827 if (cie->can_make_lsda_relative && GET_RELOC (buf))
828 cie->cie_inf->u.cie.make_lsda_relative = 1;
829 this_inf->lsda_offset = buf - start;
830 /* If there's no 'z' augmentation, we don't know where the
831 CFA insns begin. Assume no padding. */
832 if (cie->augmentation[0] != 'z')
836 /* Skip over the augmentation data. */
837 REQUIRE (skip_bytes (&buf, end, length));
840 buf = last_fde + 4 + hdr_length;
842 /* For NULL RSEC (cleared FDE belonging to a discarded section)
843 the relocations are commonly cleared. We do not sanity check if
844 all these relocations are cleared as (1) relocations to
845 .gcc_except_table will remain uncleared (they will get dropped
846 with the drop of this unused FDE) and (2) BFD already safely drops
847 relocations of any type to .eh_frame by
848 elf_section_ignore_discarded_relocs.
849 TODO: The .gcc_except_table entries should be also filtered as
850 .eh_frame entries; or GCC could rather use COMDAT for them. */
854 /* Try to interpret the CFA instructions and find the first
855 padding nop. Shrink this_inf's size so that it doesn't
856 include the padding. */
857 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
859 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
860 /* If we don't understand the CFA instructions, we can't know
861 what needs to be adjusted there. */
862 if (insns_end == NULL
863 /* For the time being we don't support DW_CFA_set_loc in
865 || (set_loc_count && this_inf->cie))
867 this_inf->size -= end - insns_end;
868 if (insns_end != end && this_inf->cie)
870 cie->initial_insn_length -= end - insns_end;
871 cie->length -= end - insns_end;
874 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
875 || this_inf->make_relative))
880 this_inf->set_loc = (unsigned int *)
881 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
882 REQUIRE (this_inf->set_loc);
883 this_inf->set_loc[0] = set_loc_count;
888 if (*p == DW_CFA_set_loc)
889 this_inf->set_loc[++cnt] = p + 1 - start;
890 REQUIRE (skip_cfa_op (&p, end, length));
894 this_inf->removed = 1;
895 this_inf->fde_encoding = cie->fde_encoding;
896 this_inf->lsda_encoding = cie->lsda_encoding;
899 BFD_ASSERT (sec_info->count == num_entries);
900 BFD_ASSERT (cie_count == num_cies);
902 elf_section_data (sec)->sec_info = sec_info;
903 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
904 if (hdr_info->merge_cies)
906 sec_info->cies = local_cies;
912 (*info->callbacks->einfo)
913 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
915 hdr_info->table = FALSE;
926 /* Finish a pass over all .eh_frame sections. */
929 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
931 struct eh_frame_hdr_info *hdr_info;
933 hdr_info = &elf_hash_table (info)->eh_info;
934 hdr_info->parsed_eh_frames = TRUE;
937 /* Mark all relocations against CIE or FDE ENT, which occurs in
938 .eh_frame section SEC. COOKIE describes the relocations in SEC;
939 its "rel" field can be changed freely. */
942 mark_entry (struct bfd_link_info *info, asection *sec,
943 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
944 struct elf_reloc_cookie *cookie)
946 /* FIXME: octets_per_byte. */
947 for (cookie->rel = cookie->rels + ent->reloc_index;
948 cookie->rel < cookie->relend
949 && cookie->rel->r_offset < ent->offset + ent->size;
951 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
957 /* Mark all the relocations against FDEs that relate to code in input
958 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
959 relocations are described by COOKIE. */
962 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
963 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
964 struct elf_reloc_cookie *cookie)
966 struct eh_cie_fde *fde, *cie;
968 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
970 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
973 /* At this stage, all cie_inf fields point to local CIEs, so we
974 can use the same cookie to refer to them. */
975 cie = fde->u.fde.cie_inf;
976 if (!cie->u.cie.gc_mark)
978 cie->u.cie.gc_mark = 1;
979 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
986 /* Input section SEC of ABFD is an .eh_frame section that contains the
987 CIE described by CIE_INF. Return a version of CIE_INF that is going
988 to be kept in the output, adding CIE_INF to the output if necessary.
990 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
991 relocations in REL. */
993 static struct eh_cie_fde *
994 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
995 struct eh_frame_hdr_info *hdr_info,
996 struct elf_reloc_cookie *cookie,
997 struct eh_cie_fde *cie_inf)
999 unsigned long r_symndx;
1000 struct cie *cie, *new_cie;
1001 Elf_Internal_Rela *rel;
1004 /* Use CIE_INF if we have already decided to keep it. */
1005 if (!cie_inf->removed)
1008 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1009 if (cie_inf->u.cie.merged)
1010 return cie_inf->u.cie.u.merged_with;
1012 cie = cie_inf->u.cie.u.full_cie;
1014 /* Assume we will need to keep CIE_INF. */
1015 cie_inf->removed = 0;
1016 cie_inf->u.cie.u.sec = sec;
1018 /* If we are not merging CIEs, use CIE_INF. */
1022 if (cie->per_encoding != DW_EH_PE_omit)
1024 bfd_boolean per_binds_local;
1026 /* Work out the address of personality routine, either as an absolute
1027 value or as a symbol. */
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.val = (sym->st_value
1068 + sym_sec->output_offset
1069 + sym_sec->output_section->vma);
1070 per_binds_local = TRUE;
1075 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1076 && (get_elf_backend_data (abfd)
1077 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1079 cie_inf->u.cie.make_per_encoding_relative = 1;
1080 cie_inf->u.cie.per_encoding_relative = 1;
1084 /* See if we can merge this CIE with an earlier one. */
1085 cie->output_sec = sec->output_section;
1086 cie_compute_hash (cie);
1087 if (hdr_info->cies == NULL)
1089 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1090 if (hdr_info->cies == NULL)
1093 loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1097 new_cie = (struct cie *) *loc;
1098 if (new_cie == NULL)
1100 /* Keep CIE_INF and record it in the hash table. */
1101 new_cie = (struct cie *) malloc (sizeof (struct cie));
1102 if (new_cie == NULL)
1105 memcpy (new_cie, cie, sizeof (struct cie));
1110 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1111 cie_inf->removed = 1;
1112 cie_inf->u.cie.merged = 1;
1113 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1114 if (cie_inf->u.cie.make_lsda_relative)
1115 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1117 return new_cie->cie_inf;
1120 /* This function is called for each input file before the .eh_frame
1121 section is relocated. It discards duplicate CIEs and FDEs for discarded
1122 functions. The function returns TRUE iff any entries have been
1126 _bfd_elf_discard_section_eh_frame
1127 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1128 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1129 struct elf_reloc_cookie *cookie)
1131 struct eh_cie_fde *ent;
1132 struct eh_frame_sec_info *sec_info;
1133 struct eh_frame_hdr_info *hdr_info;
1134 unsigned int ptr_size, offset;
1136 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1137 if (sec_info == NULL)
1140 hdr_info = &elf_hash_table (info)->eh_info;
1141 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1143 /* There should only be one zero terminator, on the last input
1144 file supplying .eh_frame (crtend.o). Remove any others. */
1145 ent->removed = sec->map_head.s != NULL;
1148 cookie->rel = cookie->rels + ent->reloc_index;
1149 /* FIXME: octets_per_byte. */
1150 BFD_ASSERT (cookie->rel < cookie->relend
1151 && cookie->rel->r_offset == ent->offset + 8);
1152 if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1155 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1156 && ent->make_relative == 0)
1157 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1159 /* If a shared library uses absolute pointers
1160 which we cannot turn into PC relative,
1161 don't create the binary search table,
1162 since it is affected by runtime relocations. */
1163 hdr_info->table = FALSE;
1164 (*info->callbacks->einfo)
1165 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1166 " table being created.\n"), abfd, sec);
1169 hdr_info->fde_count++;
1170 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1171 cookie, ent->u.fde.cie_inf);
1177 free (sec_info->cies);
1178 sec_info->cies = NULL;
1181 ptr_size = (get_elf_backend_data (sec->owner)
1182 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1184 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1187 ent->new_offset = offset;
1188 offset += size_of_output_cie_fde (ent, ptr_size);
1191 sec->rawsize = sec->size;
1193 return offset != sec->rawsize;
1196 /* This function is called for .eh_frame_hdr section after
1197 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1198 input sections. It finalizes the size of .eh_frame_hdr section. */
1201 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1203 struct elf_link_hash_table *htab;
1204 struct eh_frame_hdr_info *hdr_info;
1207 htab = elf_hash_table (info);
1208 hdr_info = &htab->eh_info;
1210 if (hdr_info->cies != NULL)
1212 htab_delete (hdr_info->cies);
1213 hdr_info->cies = NULL;
1216 sec = hdr_info->hdr_sec;
1220 sec->size = EH_FRAME_HDR_SIZE;
1221 if (hdr_info->table)
1222 sec->size += 4 + hdr_info->fde_count * 8;
1224 elf_tdata (abfd)->eh_frame_hdr = sec;
1228 /* This function is called from size_dynamic_sections.
1229 It needs to decide whether .eh_frame_hdr should be output or not,
1230 because when the dynamic symbol table has been sized it is too late
1231 to strip sections. */
1234 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1238 struct elf_link_hash_table *htab;
1239 struct eh_frame_hdr_info *hdr_info;
1241 htab = elf_hash_table (info);
1242 hdr_info = &htab->eh_info;
1243 if (hdr_info->hdr_sec == NULL)
1246 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1248 hdr_info->hdr_sec = NULL;
1253 if (info->eh_frame_hdr)
1254 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1256 /* Count only sections which have at least a single CIE or FDE.
1257 There cannot be any CIE or FDE <= 8 bytes. */
1258 o = bfd_get_section_by_name (abfd, ".eh_frame");
1259 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1265 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1266 hdr_info->hdr_sec = NULL;
1270 hdr_info->table = TRUE;
1274 /* Adjust an address in the .eh_frame section. Given OFFSET within
1275 SEC, this returns the new offset in the adjusted .eh_frame section,
1276 or -1 if the address refers to a CIE/FDE which has been removed
1277 or to offset with dynamic relocation which is no longer needed. */
1280 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1281 struct bfd_link_info *info,
1285 struct eh_frame_sec_info *sec_info;
1286 struct elf_link_hash_table *htab;
1287 struct eh_frame_hdr_info *hdr_info;
1288 unsigned int lo, hi, mid;
1290 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1292 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1294 if (offset >= sec->rawsize)
1295 return offset - sec->rawsize + sec->size;
1297 htab = elf_hash_table (info);
1298 hdr_info = &htab->eh_info;
1301 hi = sec_info->count;
1305 mid = (lo + hi) / 2;
1306 if (offset < sec_info->entry[mid].offset)
1309 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1315 BFD_ASSERT (lo < hi);
1317 /* FDE or CIE was removed. */
1318 if (sec_info->entry[mid].removed)
1319 return (bfd_vma) -1;
1321 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1322 no need for run-time relocation against the personality field. */
1323 if (sec_info->entry[mid].cie
1324 && sec_info->entry[mid].u.cie.make_per_encoding_relative
1325 && offset == (sec_info->entry[mid].offset + 8
1326 + sec_info->entry[mid].u.cie.personality_offset))
1327 return (bfd_vma) -2;
1329 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1330 relocation against FDE's initial_location field. */
1331 if (!sec_info->entry[mid].cie
1332 && sec_info->entry[mid].make_relative
1333 && offset == sec_info->entry[mid].offset + 8)
1334 return (bfd_vma) -2;
1336 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1337 for run-time relocation against LSDA field. */
1338 if (!sec_info->entry[mid].cie
1339 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1340 && offset == (sec_info->entry[mid].offset + 8
1341 + sec_info->entry[mid].lsda_offset))
1342 return (bfd_vma) -2;
1344 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1345 relocation against DW_CFA_set_loc's arguments. */
1346 if (sec_info->entry[mid].set_loc
1347 && sec_info->entry[mid].make_relative
1348 && (offset >= sec_info->entry[mid].offset + 8
1349 + sec_info->entry[mid].set_loc[1]))
1353 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1354 if (offset == sec_info->entry[mid].offset + 8
1355 + sec_info->entry[mid].set_loc[cnt])
1356 return (bfd_vma) -2;
1359 /* Any new augmentation bytes go before the first relocation. */
1360 return (offset + sec_info->entry[mid].new_offset
1361 - sec_info->entry[mid].offset
1362 + extra_augmentation_string_bytes (sec_info->entry + mid)
1363 + extra_augmentation_data_bytes (sec_info->entry + mid));
1366 /* Write out .eh_frame section. This is called with the relocated
1370 _bfd_elf_write_section_eh_frame (bfd *abfd,
1371 struct bfd_link_info *info,
1375 struct eh_frame_sec_info *sec_info;
1376 struct elf_link_hash_table *htab;
1377 struct eh_frame_hdr_info *hdr_info;
1378 unsigned int ptr_size;
1379 struct eh_cie_fde *ent;
1381 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1382 /* FIXME: octets_per_byte. */
1383 return bfd_set_section_contents (abfd, sec->output_section, contents,
1384 sec->output_offset, sec->size);
1386 ptr_size = (get_elf_backend_data (abfd)
1387 ->elf_backend_eh_frame_address_size (abfd, sec));
1388 BFD_ASSERT (ptr_size != 0);
1390 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1391 htab = elf_hash_table (info);
1392 hdr_info = &htab->eh_info;
1394 if (hdr_info->table && hdr_info->array == NULL)
1395 hdr_info->array = (struct eh_frame_array_ent *)
1396 bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1397 if (hdr_info->array == NULL)
1400 /* The new offsets can be bigger or smaller than the original offsets.
1401 We therefore need to make two passes over the section: one backward
1402 pass to move entries up and one forward pass to move entries down.
1403 The two passes won't interfere with each other because entries are
1405 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1406 if (!ent->removed && ent->new_offset > ent->offset)
1407 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1409 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1410 if (!ent->removed && ent->new_offset < ent->offset)
1411 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1413 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1415 unsigned char *buf, *end;
1416 unsigned int new_size;
1423 /* Any terminating FDE must be at the end of the section. */
1424 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1428 buf = contents + ent->new_offset;
1429 end = buf + ent->size;
1430 new_size = size_of_output_cie_fde (ent, ptr_size);
1432 /* Update the size. It may be shrinked. */
1433 bfd_put_32 (abfd, new_size - 4, buf);
1435 /* Filling the extra bytes with DW_CFA_nops. */
1436 if (new_size != ent->size)
1437 memset (end, 0, new_size - ent->size);
1442 if (ent->make_relative
1443 || ent->u.cie.make_lsda_relative
1444 || ent->u.cie.per_encoding_relative)
1447 unsigned int action, extra_string, extra_data;
1448 unsigned int per_width, per_encoding;
1450 /* Need to find 'R' or 'L' augmentation's argument and modify
1451 DW_EH_PE_* value. */
1452 action = ((ent->make_relative ? 1 : 0)
1453 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1454 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1455 extra_string = extra_augmentation_string_bytes (ent);
1456 extra_data = extra_augmentation_data_bytes (ent);
1458 /* Skip length, id and version. */
1461 buf += strlen (aug) + 1;
1462 skip_leb128 (&buf, end);
1463 skip_leb128 (&buf, end);
1464 skip_leb128 (&buf, end);
1467 /* The uleb128 will always be a single byte for the kind
1468 of augmentation strings that we're prepared to handle. */
1469 *buf++ += extra_data;
1473 /* Make room for the new augmentation string and data bytes. */
1474 memmove (buf + extra_string + extra_data, buf, end - buf);
1475 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1476 buf += extra_string;
1477 end += extra_string + extra_data;
1479 if (ent->add_augmentation_size)
1482 *buf++ = extra_data - 1;
1484 if (ent->u.cie.add_fde_encoding)
1486 BFD_ASSERT (action & 1);
1488 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1498 BFD_ASSERT (*buf == ent->lsda_encoding);
1499 *buf = make_pc_relative (*buf, ptr_size);
1505 if (ent->u.cie.make_per_encoding_relative)
1506 *buf = make_pc_relative (*buf, ptr_size);
1507 per_encoding = *buf++;
1508 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1509 BFD_ASSERT (per_width != 0);
1510 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1511 == ent->u.cie.per_encoding_relative);
1512 if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1514 + ((buf - contents + per_width - 1)
1515 & ~((bfd_size_type) per_width - 1)));
1520 val = read_value (abfd, buf, per_width,
1521 get_DW_EH_PE_signed (per_encoding));
1522 if (ent->u.cie.make_per_encoding_relative)
1523 val -= (sec->output_section->vma
1524 + sec->output_offset
1525 + (buf - contents));
1528 val += (bfd_vma) ent->offset - ent->new_offset;
1529 val -= extra_string + extra_data;
1531 write_value (abfd, buf, val, per_width);
1539 BFD_ASSERT (*buf == ent->fde_encoding);
1540 *buf = make_pc_relative (*buf, ptr_size);
1555 bfd_vma value, address;
1558 struct eh_cie_fde *cie;
1561 cie = ent->u.fde.cie_inf;
1563 value = ((ent->new_offset + sec->output_offset + 4)
1564 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1565 bfd_put_32 (abfd, value, buf);
1567 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1568 value = read_value (abfd, buf, width,
1569 get_DW_EH_PE_signed (ent->fde_encoding));
1573 switch (ent->fde_encoding & 0x70)
1575 case DW_EH_PE_textrel:
1576 BFD_ASSERT (hdr_info == NULL);
1578 case DW_EH_PE_datarel:
1580 asection *got = bfd_get_section_by_name (abfd, ".got");
1582 BFD_ASSERT (got != NULL);
1583 address += got->vma;
1586 case DW_EH_PE_pcrel:
1587 value += (bfd_vma) ent->offset - ent->new_offset;
1588 address += (sec->output_section->vma
1589 + sec->output_offset
1593 if (ent->make_relative)
1594 value -= (sec->output_section->vma
1595 + sec->output_offset
1596 + ent->new_offset + 8);
1597 write_value (abfd, buf, value, width);
1604 hdr_info->array[hdr_info->array_count].initial_loc = address;
1605 hdr_info->array[hdr_info->array_count++].fde
1606 = (sec->output_section->vma
1607 + sec->output_offset
1611 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1612 || cie->u.cie.make_lsda_relative)
1614 buf += ent->lsda_offset;
1615 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1616 value = read_value (abfd, buf, width,
1617 get_DW_EH_PE_signed (ent->lsda_encoding));
1620 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1621 value += (bfd_vma) ent->offset - ent->new_offset;
1622 else if (cie->u.cie.make_lsda_relative)
1623 value -= (sec->output_section->vma
1624 + sec->output_offset
1625 + ent->new_offset + 8 + ent->lsda_offset);
1626 write_value (abfd, buf, value, width);
1629 else if (ent->add_augmentation_size)
1631 /* Skip the PC and length and insert a zero byte for the
1632 augmentation size. */
1634 memmove (buf + 1, buf, end - buf);
1640 /* Adjust DW_CFA_set_loc. */
1644 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1645 new_offset = ent->new_offset + 8
1646 + extra_augmentation_string_bytes (ent)
1647 + extra_augmentation_data_bytes (ent);
1649 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1651 buf = start + ent->set_loc[cnt];
1653 value = read_value (abfd, buf, width,
1654 get_DW_EH_PE_signed (ent->fde_encoding));
1658 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1659 value += (bfd_vma) ent->offset + 8 - new_offset;
1660 if (ent->make_relative)
1661 value -= (sec->output_section->vma
1662 + sec->output_offset
1663 + new_offset + ent->set_loc[cnt]);
1664 write_value (abfd, buf, value, width);
1670 /* We don't align the section to its section alignment since the
1671 runtime library only expects all CIE/FDE records aligned at
1672 the pointer size. _bfd_elf_discard_section_eh_frame should
1673 have padded CIE/FDE records to multiple of pointer size with
1674 size_of_output_cie_fde. */
1675 if ((sec->size % ptr_size) != 0)
1678 /* FIXME: octets_per_byte. */
1679 return bfd_set_section_contents (abfd, sec->output_section,
1680 contents, (file_ptr) sec->output_offset,
1684 /* Helper function used to sort .eh_frame_hdr search table by increasing
1685 VMA of FDE initial location. */
1688 vma_compare (const void *a, const void *b)
1690 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1691 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1692 if (p->initial_loc > q->initial_loc)
1694 if (p->initial_loc < q->initial_loc)
1699 /* Write out .eh_frame_hdr section. This must be called after
1700 _bfd_elf_write_section_eh_frame has been called on all input
1702 .eh_frame_hdr format:
1703 ubyte version (currently 1)
1704 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1706 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1707 number (or DW_EH_PE_omit if there is no
1708 binary search table computed))
1709 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1710 or DW_EH_PE_omit if not present.
1711 DW_EH_PE_datarel is using address of
1712 .eh_frame_hdr section start as base)
1713 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1714 optionally followed by:
1715 [encoded] fde_count (total number of FDEs in .eh_frame section)
1716 fde_count x [encoded] initial_loc, fde
1717 (array of encoded pairs containing
1718 FDE initial_location field and FDE address,
1719 sorted by increasing initial_loc). */
1722 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1724 struct elf_link_hash_table *htab;
1725 struct eh_frame_hdr_info *hdr_info;
1728 asection *eh_frame_sec;
1731 bfd_vma encoded_eh_frame;
1733 htab = elf_hash_table (info);
1734 hdr_info = &htab->eh_info;
1735 sec = hdr_info->hdr_sec;
1739 size = EH_FRAME_HDR_SIZE;
1740 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1741 size += 4 + hdr_info->fde_count * 8;
1742 contents = (bfd_byte *) bfd_malloc (size);
1743 if (contents == NULL)
1746 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1747 if (eh_frame_sec == NULL)
1753 memset (contents, 0, EH_FRAME_HDR_SIZE);
1754 contents[0] = 1; /* Version. */
1755 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1756 (abfd, info, eh_frame_sec, 0, sec, 4,
1757 &encoded_eh_frame); /* .eh_frame offset. */
1759 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1761 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1762 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1766 contents[2] = DW_EH_PE_omit;
1767 contents[3] = DW_EH_PE_omit;
1769 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1771 if (contents[2] != DW_EH_PE_omit)
1775 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1776 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1778 for (i = 0; i < hdr_info->fde_count; i++)
1781 hdr_info->array[i].initial_loc
1782 - sec->output_section->vma,
1783 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1785 hdr_info->array[i].fde - sec->output_section->vma,
1786 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1790 /* FIXME: octets_per_byte. */
1791 retval = bfd_set_section_contents (abfd, sec->output_section,
1792 contents, (file_ptr) sec->output_offset,
1798 /* Return the width of FDE addresses. This is the default implementation. */
1801 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1803 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1806 /* Decide whether we can use a PC-relative encoding within the given
1807 EH frame section. This is the default implementation. */
1810 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1811 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1812 asection *eh_frame_section ATTRIBUTE_UNUSED)
1817 /* Select an encoding for the given address. Preference is given to
1818 PC-relative addressing modes. */
1821 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1822 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1823 asection *osec, bfd_vma offset,
1824 asection *loc_sec, bfd_vma loc_offset,
1827 *encoded = osec->vma + offset -
1828 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1829 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;