1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
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)
494 || sec->sec_info_type != ELF_INFO_TYPE_NONE)
496 /* This file does not contain .eh_frame information. */
500 if (bfd_is_abs_section (sec->output_section))
502 /* At least one of the sections is being discarded from the
503 link, so we should just ignore them. */
507 /* Read the frame unwind information from abfd. */
509 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
512 && bfd_get_32 (abfd, ehbuf) == 0
513 && cookie->rel == cookie->relend)
515 /* Empty .eh_frame section. */
520 /* If .eh_frame section size doesn't fit into int, we cannot handle
521 it (it would need to use 64-bit .eh_frame format anyway). */
522 REQUIRE (sec->size == (unsigned int) sec->size);
524 ptr_size = (get_elf_backend_data (abfd)
525 ->elf_backend_eh_frame_address_size (abfd, sec));
526 REQUIRE (ptr_size != 0);
528 /* Go through the section contents and work out how many FDEs and
531 end = ehbuf + sec->size;
538 /* Read the length of the entry. */
539 REQUIRE (skip_bytes (&buf, end, 4));
540 hdr_length = bfd_get_32 (abfd, buf - 4);
542 /* 64-bit .eh_frame is not supported. */
543 REQUIRE (hdr_length != 0xffffffff);
547 REQUIRE (skip_bytes (&buf, end, 4));
548 hdr_id = bfd_get_32 (abfd, buf - 4);
552 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
555 sec_info = (struct eh_frame_sec_info *)
556 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
557 + (num_entries - 1) * sizeof (struct eh_cie_fde));
560 /* We need to have a "struct cie" for each CIE in this section. */
561 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
562 REQUIRE (local_cies);
564 /* FIXME: octets_per_byte. */
565 #define ENSURE_NO_RELOCS(buf) \
566 REQUIRE (!(cookie->rel < cookie->relend \
567 && (cookie->rel->r_offset \
568 < (bfd_size_type) ((buf) - ehbuf)) \
569 && cookie->rel->r_info != 0))
571 /* FIXME: octets_per_byte. */
572 #define SKIP_RELOCS(buf) \
573 while (cookie->rel < cookie->relend \
574 && (cookie->rel->r_offset \
575 < (bfd_size_type) ((buf) - ehbuf))) \
578 /* FIXME: octets_per_byte. */
579 #define GET_RELOC(buf) \
580 ((cookie->rel < cookie->relend \
581 && (cookie->rel->r_offset \
582 == (bfd_size_type) ((buf) - ehbuf))) \
583 ? cookie->rel : NULL)
587 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
588 while ((bfd_size_type) (buf - ehbuf) != sec->size)
591 bfd_byte *start, *insns, *insns_end;
592 bfd_size_type length;
593 unsigned int set_loc_count;
595 this_inf = sec_info->entry + sec_info->count;
598 /* Read the length of the entry. */
599 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
600 hdr_length = bfd_get_32 (abfd, buf - 4);
602 /* The CIE/FDE must be fully contained in this input section. */
603 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
604 end = buf + hdr_length;
606 this_inf->offset = last_fde - ehbuf;
607 this_inf->size = 4 + hdr_length;
608 this_inf->reloc_index = cookie->rel - cookie->rels;
612 /* A zero-length CIE should only be found at the end of
614 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
615 ENSURE_NO_RELOCS (buf);
620 REQUIRE (skip_bytes (&buf, end, 4));
621 hdr_id = bfd_get_32 (abfd, buf - 4);
625 unsigned int initial_insn_length;
630 /* Point CIE to one of the section-local cie structures. */
631 cie = local_cies + cie_count++;
633 cie->cie_inf = this_inf;
634 cie->length = hdr_length;
635 cie->output_sec = sec->output_section;
637 REQUIRE (read_byte (&buf, end, &cie->version));
639 /* Cannot handle unknown versions. */
640 REQUIRE (cie->version == 1
642 || cie->version == 4);
643 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
645 strcpy (cie->augmentation, (char *) buf);
646 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
647 ENSURE_NO_RELOCS (buf);
648 if (buf[0] == 'e' && buf[1] == 'h')
650 /* GCC < 3.0 .eh_frame CIE */
651 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
652 is private to each CIE, so we don't need it for anything.
654 REQUIRE (skip_bytes (&buf, end, ptr_size));
657 if (cie->version >= 4)
659 REQUIRE (buf + 1 < end);
660 REQUIRE (buf[0] == ptr_size);
661 REQUIRE (buf[1] == 0);
664 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
665 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
666 if (cie->version == 1)
669 cie->ra_column = *buf++;
672 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
673 ENSURE_NO_RELOCS (buf);
674 cie->lsda_encoding = DW_EH_PE_omit;
675 cie->fde_encoding = DW_EH_PE_omit;
676 cie->per_encoding = DW_EH_PE_omit;
677 aug = cie->augmentation;
678 if (aug[0] != 'e' || aug[1] != 'h')
683 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
684 ENSURE_NO_RELOCS (buf);
691 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
692 ENSURE_NO_RELOCS (buf);
693 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
696 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
697 ENSURE_NO_RELOCS (buf);
698 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
706 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
707 per_width = get_DW_EH_PE_width (cie->per_encoding,
710 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
712 length = -(buf - ehbuf) & (per_width - 1);
713 REQUIRE (skip_bytes (&buf, end, length));
715 this_inf->u.cie.personality_offset = buf - start;
716 ENSURE_NO_RELOCS (buf);
717 /* Ensure we have a reloc here. */
718 REQUIRE (GET_RELOC (buf));
719 cie->personality.reloc_index
720 = cookie->rel - cookie->rels;
721 /* Cope with MIPS-style composite relocations. */
724 while (GET_RELOC (buf) != NULL);
725 REQUIRE (skip_bytes (&buf, end, per_width));
729 /* Unrecognized augmentation. Better bail out. */
734 /* For shared libraries, try to get rid of as many RELATIVE relocs
737 && (get_elf_backend_data (abfd)
738 ->elf_backend_can_make_relative_eh_frame
741 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
742 this_inf->make_relative = 1;
743 /* If the CIE doesn't already have an 'R' entry, it's fairly
744 easy to add one, provided that there's no aligned data
745 after the augmentation string. */
746 else if (cie->fde_encoding == DW_EH_PE_omit
747 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
749 if (*cie->augmentation == 0)
750 this_inf->add_augmentation_size = 1;
751 this_inf->u.cie.add_fde_encoding = 1;
752 this_inf->make_relative = 1;
755 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
756 cie->can_make_lsda_relative = 1;
759 /* If FDE encoding was not specified, it defaults to
761 if (cie->fde_encoding == DW_EH_PE_omit)
762 cie->fde_encoding = DW_EH_PE_absptr;
764 initial_insn_length = end - buf;
765 if (initial_insn_length <= sizeof (cie->initial_instructions))
767 cie->initial_insn_length = initial_insn_length;
768 memcpy (cie->initial_instructions, buf, initial_insn_length);
771 buf += initial_insn_length;
772 ENSURE_NO_RELOCS (buf);
774 if (hdr_info->merge_cies)
775 this_inf->u.cie.u.full_cie = cie;
776 this_inf->u.cie.per_encoding_relative
777 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
783 /* Find the corresponding CIE. */
784 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
785 for (cie = local_cies; cie < local_cies + cie_count; cie++)
786 if (cie_offset == cie->cie_inf->offset)
789 /* Ensure this FDE references one of the CIEs in this input
791 REQUIRE (cie != local_cies + cie_count);
792 this_inf->u.fde.cie_inf = cie->cie_inf;
793 this_inf->make_relative = cie->cie_inf->make_relative;
794 this_inf->add_augmentation_size
795 = cie->cie_inf->add_augmentation_size;
797 ENSURE_NO_RELOCS (buf);
798 REQUIRE (GET_RELOC (buf));
800 /* Chain together the FDEs for each section. */
801 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
802 /* RSEC will be NULL if FDE was cleared out as it was belonging to
803 a discarded SHT_GROUP. */
806 REQUIRE (rsec->owner == abfd);
807 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
808 elf_fde_list (rsec) = this_inf;
811 /* Skip the initial location and address range. */
813 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
814 REQUIRE (skip_bytes (&buf, end, 2 * length));
816 /* Skip the augmentation size, if present. */
817 if (cie->augmentation[0] == 'z')
818 REQUIRE (read_uleb128 (&buf, end, &length));
822 /* Of the supported augmentation characters above, only 'L'
823 adds augmentation data to the FDE. This code would need to
824 be adjusted if any future augmentations do the same thing. */
825 if (cie->lsda_encoding != DW_EH_PE_omit)
828 if (cie->can_make_lsda_relative && GET_RELOC (buf))
829 cie->cie_inf->u.cie.make_lsda_relative = 1;
830 this_inf->lsda_offset = buf - start;
831 /* If there's no 'z' augmentation, we don't know where the
832 CFA insns begin. Assume no padding. */
833 if (cie->augmentation[0] != 'z')
837 /* Skip over the augmentation data. */
838 REQUIRE (skip_bytes (&buf, end, length));
841 buf = last_fde + 4 + hdr_length;
843 /* For NULL RSEC (cleared FDE belonging to a discarded section)
844 the relocations are commonly cleared. We do not sanity check if
845 all these relocations are cleared as (1) relocations to
846 .gcc_except_table will remain uncleared (they will get dropped
847 with the drop of this unused FDE) and (2) BFD already safely drops
848 relocations of any type to .eh_frame by
849 elf_section_ignore_discarded_relocs.
850 TODO: The .gcc_except_table entries should be also filtered as
851 .eh_frame entries; or GCC could rather use COMDAT for them. */
855 /* Try to interpret the CFA instructions and find the first
856 padding nop. Shrink this_inf's size so that it doesn't
857 include the padding. */
858 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
860 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
861 /* If we don't understand the CFA instructions, we can't know
862 what needs to be adjusted there. */
863 if (insns_end == NULL
864 /* For the time being we don't support DW_CFA_set_loc in
866 || (set_loc_count && this_inf->cie))
868 this_inf->size -= end - insns_end;
869 if (insns_end != end && this_inf->cie)
871 cie->initial_insn_length -= end - insns_end;
872 cie->length -= end - insns_end;
875 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
876 || this_inf->make_relative))
881 this_inf->set_loc = (unsigned int *)
882 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
883 REQUIRE (this_inf->set_loc);
884 this_inf->set_loc[0] = set_loc_count;
889 if (*p == DW_CFA_set_loc)
890 this_inf->set_loc[++cnt] = p + 1 - start;
891 REQUIRE (skip_cfa_op (&p, end, length));
895 this_inf->removed = 1;
896 this_inf->fde_encoding = cie->fde_encoding;
897 this_inf->lsda_encoding = cie->lsda_encoding;
900 BFD_ASSERT (sec_info->count == num_entries);
901 BFD_ASSERT (cie_count == num_cies);
903 elf_section_data (sec)->sec_info = sec_info;
904 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
905 if (hdr_info->merge_cies)
907 sec_info->cies = local_cies;
913 (*info->callbacks->einfo)
914 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
916 hdr_info->table = FALSE;
927 /* Finish a pass over all .eh_frame sections. */
930 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
932 struct eh_frame_hdr_info *hdr_info;
934 hdr_info = &elf_hash_table (info)->eh_info;
935 hdr_info->parsed_eh_frames = TRUE;
938 /* Mark all relocations against CIE or FDE ENT, which occurs in
939 .eh_frame section SEC. COOKIE describes the relocations in SEC;
940 its "rel" field can be changed freely. */
943 mark_entry (struct bfd_link_info *info, asection *sec,
944 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
945 struct elf_reloc_cookie *cookie)
947 /* FIXME: octets_per_byte. */
948 for (cookie->rel = cookie->rels + ent->reloc_index;
949 cookie->rel < cookie->relend
950 && cookie->rel->r_offset < ent->offset + ent->size;
952 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
958 /* Mark all the relocations against FDEs that relate to code in input
959 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
960 relocations are described by COOKIE. */
963 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
964 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
965 struct elf_reloc_cookie *cookie)
967 struct eh_cie_fde *fde, *cie;
969 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
971 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
974 /* At this stage, all cie_inf fields point to local CIEs, so we
975 can use the same cookie to refer to them. */
976 cie = fde->u.fde.cie_inf;
977 if (!cie->u.cie.gc_mark)
979 cie->u.cie.gc_mark = 1;
980 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
987 /* Input section SEC of ABFD is an .eh_frame section that contains the
988 CIE described by CIE_INF. Return a version of CIE_INF that is going
989 to be kept in the output, adding CIE_INF to the output if necessary.
991 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
992 relocations in REL. */
994 static struct eh_cie_fde *
995 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
996 struct eh_frame_hdr_info *hdr_info,
997 struct elf_reloc_cookie *cookie,
998 struct eh_cie_fde *cie_inf)
1000 unsigned long r_symndx;
1001 struct cie *cie, *new_cie;
1002 Elf_Internal_Rela *rel;
1005 /* Use CIE_INF if we have already decided to keep it. */
1006 if (!cie_inf->removed)
1009 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1010 if (cie_inf->u.cie.merged)
1011 return cie_inf->u.cie.u.merged_with;
1013 cie = cie_inf->u.cie.u.full_cie;
1015 /* Assume we will need to keep CIE_INF. */
1016 cie_inf->removed = 0;
1017 cie_inf->u.cie.u.sec = sec;
1019 /* If we are not merging CIEs, use CIE_INF. */
1023 if (cie->per_encoding != DW_EH_PE_omit)
1025 bfd_boolean per_binds_local;
1027 /* Work out the address of personality routine, either as an absolute
1028 value or as a symbol. */
1029 rel = cookie->rels + cie->personality.reloc_index;
1030 memset (&cie->personality, 0, sizeof (cie->personality));
1032 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1033 r_symndx = ELF64_R_SYM (rel->r_info);
1036 r_symndx = ELF32_R_SYM (rel->r_info);
1037 if (r_symndx >= cookie->locsymcount
1038 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1040 struct elf_link_hash_entry *h;
1042 r_symndx -= cookie->extsymoff;
1043 h = cookie->sym_hashes[r_symndx];
1045 while (h->root.type == bfd_link_hash_indirect
1046 || h->root.type == bfd_link_hash_warning)
1047 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1049 cie->personality.h = h;
1050 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1054 Elf_Internal_Sym *sym;
1057 sym = &cookie->locsyms[r_symndx];
1058 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1059 if (sym_sec == NULL)
1062 if (sym_sec->kept_section != NULL)
1063 sym_sec = sym_sec->kept_section;
1064 if (sym_sec->output_section == NULL)
1067 cie->local_personality = 1;
1068 cie->personality.val = (sym->st_value
1069 + sym_sec->output_offset
1070 + sym_sec->output_section->vma);
1071 per_binds_local = TRUE;
1076 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1077 && (get_elf_backend_data (abfd)
1078 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1080 cie_inf->u.cie.make_per_encoding_relative = 1;
1081 cie_inf->u.cie.per_encoding_relative = 1;
1085 /* See if we can merge this CIE with an earlier one. */
1086 cie->output_sec = sec->output_section;
1087 cie_compute_hash (cie);
1088 if (hdr_info->cies == NULL)
1090 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1091 if (hdr_info->cies == NULL)
1094 loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1098 new_cie = (struct cie *) *loc;
1099 if (new_cie == NULL)
1101 /* Keep CIE_INF and record it in the hash table. */
1102 new_cie = (struct cie *) malloc (sizeof (struct cie));
1103 if (new_cie == NULL)
1106 memcpy (new_cie, cie, sizeof (struct cie));
1111 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1112 cie_inf->removed = 1;
1113 cie_inf->u.cie.merged = 1;
1114 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1115 if (cie_inf->u.cie.make_lsda_relative)
1116 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1118 return new_cie->cie_inf;
1121 /* This function is called for each input file before the .eh_frame
1122 section is relocated. It discards duplicate CIEs and FDEs for discarded
1123 functions. The function returns TRUE iff any entries have been
1127 _bfd_elf_discard_section_eh_frame
1128 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1129 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1130 struct elf_reloc_cookie *cookie)
1132 struct eh_cie_fde *ent;
1133 struct eh_frame_sec_info *sec_info;
1134 struct eh_frame_hdr_info *hdr_info;
1135 unsigned int ptr_size, offset;
1137 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1140 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1141 if (sec_info == NULL)
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;
1152 cookie->rel = cookie->rels + ent->reloc_index;
1153 /* FIXME: octets_per_byte. */
1154 BFD_ASSERT (cookie->rel < cookie->relend
1155 && cookie->rel->r_offset == ent->offset + 8);
1156 if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1159 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1160 && ent->make_relative == 0)
1161 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1163 /* If a shared library uses absolute pointers
1164 which we cannot turn into PC relative,
1165 don't create the binary search table,
1166 since it is affected by runtime relocations. */
1167 hdr_info->table = FALSE;
1168 (*info->callbacks->einfo)
1169 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1170 " table being created.\n"), abfd, sec);
1173 hdr_info->fde_count++;
1174 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1175 cookie, ent->u.fde.cie_inf);
1181 free (sec_info->cies);
1182 sec_info->cies = NULL;
1185 ptr_size = (get_elf_backend_data (sec->owner)
1186 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1188 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1191 ent->new_offset = offset;
1192 offset += size_of_output_cie_fde (ent, ptr_size);
1195 sec->rawsize = sec->size;
1197 return offset != sec->rawsize;
1200 /* This function is called for .eh_frame_hdr section after
1201 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1202 input sections. It finalizes the size of .eh_frame_hdr section. */
1205 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1207 struct elf_link_hash_table *htab;
1208 struct eh_frame_hdr_info *hdr_info;
1211 htab = elf_hash_table (info);
1212 hdr_info = &htab->eh_info;
1214 if (hdr_info->cies != NULL)
1216 htab_delete (hdr_info->cies);
1217 hdr_info->cies = NULL;
1220 sec = hdr_info->hdr_sec;
1224 sec->size = EH_FRAME_HDR_SIZE;
1225 if (hdr_info->table)
1226 sec->size += 4 + hdr_info->fde_count * 8;
1228 elf_tdata (abfd)->eh_frame_hdr = sec;
1232 /* This function is called from size_dynamic_sections.
1233 It needs to decide whether .eh_frame_hdr should be output or not,
1234 because when the dynamic symbol table has been sized it is too late
1235 to strip sections. */
1238 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1242 struct elf_link_hash_table *htab;
1243 struct eh_frame_hdr_info *hdr_info;
1245 htab = elf_hash_table (info);
1246 hdr_info = &htab->eh_info;
1247 if (hdr_info->hdr_sec == NULL)
1250 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1252 hdr_info->hdr_sec = NULL;
1257 if (info->eh_frame_hdr)
1258 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1260 /* Count only sections which have at least a single CIE or FDE.
1261 There cannot be any CIE or FDE <= 8 bytes. */
1262 o = bfd_get_section_by_name (abfd, ".eh_frame");
1263 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1269 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1270 hdr_info->hdr_sec = NULL;
1274 hdr_info->table = TRUE;
1278 /* Adjust an address in the .eh_frame section. Given OFFSET within
1279 SEC, this returns the new offset in the adjusted .eh_frame section,
1280 or -1 if the address refers to a CIE/FDE which has been removed
1281 or to offset with dynamic relocation which is no longer needed. */
1284 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1285 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1289 struct eh_frame_sec_info *sec_info;
1290 unsigned int lo, hi, mid;
1292 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1294 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1296 if (offset >= sec->rawsize)
1297 return offset - sec->rawsize + sec->size;
1300 hi = sec_info->count;
1304 mid = (lo + hi) / 2;
1305 if (offset < sec_info->entry[mid].offset)
1308 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1314 BFD_ASSERT (lo < hi);
1316 /* FDE or CIE was removed. */
1317 if (sec_info->entry[mid].removed)
1318 return (bfd_vma) -1;
1320 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1321 no need for run-time relocation against the personality field. */
1322 if (sec_info->entry[mid].cie
1323 && sec_info->entry[mid].u.cie.make_per_encoding_relative
1324 && offset == (sec_info->entry[mid].offset + 8
1325 + sec_info->entry[mid].u.cie.personality_offset))
1326 return (bfd_vma) -2;
1328 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1329 relocation against FDE's initial_location field. */
1330 if (!sec_info->entry[mid].cie
1331 && sec_info->entry[mid].make_relative
1332 && offset == sec_info->entry[mid].offset + 8)
1333 return (bfd_vma) -2;
1335 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1336 for run-time relocation against LSDA field. */
1337 if (!sec_info->entry[mid].cie
1338 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1339 && offset == (sec_info->entry[mid].offset + 8
1340 + sec_info->entry[mid].lsda_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 DW_CFA_set_loc's arguments. */
1345 if (sec_info->entry[mid].set_loc
1346 && sec_info->entry[mid].make_relative
1347 && (offset >= sec_info->entry[mid].offset + 8
1348 + sec_info->entry[mid].set_loc[1]))
1352 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1353 if (offset == sec_info->entry[mid].offset + 8
1354 + sec_info->entry[mid].set_loc[cnt])
1355 return (bfd_vma) -2;
1358 /* Any new augmentation bytes go before the first relocation. */
1359 return (offset + sec_info->entry[mid].new_offset
1360 - sec_info->entry[mid].offset
1361 + extra_augmentation_string_bytes (sec_info->entry + mid)
1362 + extra_augmentation_data_bytes (sec_info->entry + mid));
1365 /* Write out .eh_frame section. This is called with the relocated
1369 _bfd_elf_write_section_eh_frame (bfd *abfd,
1370 struct bfd_link_info *info,
1374 struct eh_frame_sec_info *sec_info;
1375 struct elf_link_hash_table *htab;
1376 struct eh_frame_hdr_info *hdr_info;
1377 unsigned int ptr_size;
1378 struct eh_cie_fde *ent;
1380 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1381 /* FIXME: octets_per_byte. */
1382 return bfd_set_section_contents (abfd, sec->output_section, contents,
1383 sec->output_offset, sec->size);
1385 ptr_size = (get_elf_backend_data (abfd)
1386 ->elf_backend_eh_frame_address_size (abfd, sec));
1387 BFD_ASSERT (ptr_size != 0);
1389 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1390 htab = elf_hash_table (info);
1391 hdr_info = &htab->eh_info;
1393 if (hdr_info->table && hdr_info->array == NULL)
1394 hdr_info->array = (struct eh_frame_array_ent *)
1395 bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1396 if (hdr_info->array == NULL)
1399 /* The new offsets can be bigger or smaller than the original offsets.
1400 We therefore need to make two passes over the section: one backward
1401 pass to move entries up and one forward pass to move entries down.
1402 The two passes won't interfere with each other because entries are
1404 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1405 if (!ent->removed && ent->new_offset > ent->offset)
1406 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1408 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1409 if (!ent->removed && ent->new_offset < ent->offset)
1410 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1412 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1414 unsigned char *buf, *end;
1415 unsigned int new_size;
1422 /* Any terminating FDE must be at the end of the section. */
1423 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1427 buf = contents + ent->new_offset;
1428 end = buf + ent->size;
1429 new_size = size_of_output_cie_fde (ent, ptr_size);
1431 /* Update the size. It may be shrinked. */
1432 bfd_put_32 (abfd, new_size - 4, buf);
1434 /* Filling the extra bytes with DW_CFA_nops. */
1435 if (new_size != ent->size)
1436 memset (end, 0, new_size - ent->size);
1441 if (ent->make_relative
1442 || ent->u.cie.make_lsda_relative
1443 || ent->u.cie.per_encoding_relative)
1446 unsigned int action, extra_string, extra_data;
1447 unsigned int per_width, per_encoding;
1449 /* Need to find 'R' or 'L' augmentation's argument and modify
1450 DW_EH_PE_* value. */
1451 action = ((ent->make_relative ? 1 : 0)
1452 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1453 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1454 extra_string = extra_augmentation_string_bytes (ent);
1455 extra_data = extra_augmentation_data_bytes (ent);
1457 /* Skip length, id and version. */
1460 buf += strlen (aug) + 1;
1461 skip_leb128 (&buf, end);
1462 skip_leb128 (&buf, end);
1463 skip_leb128 (&buf, end);
1466 /* The uleb128 will always be a single byte for the kind
1467 of augmentation strings that we're prepared to handle. */
1468 *buf++ += extra_data;
1472 /* Make room for the new augmentation string and data bytes. */
1473 memmove (buf + extra_string + extra_data, buf, end - buf);
1474 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1475 buf += extra_string;
1476 end += extra_string + extra_data;
1478 if (ent->add_augmentation_size)
1481 *buf++ = extra_data - 1;
1483 if (ent->u.cie.add_fde_encoding)
1485 BFD_ASSERT (action & 1);
1487 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1497 BFD_ASSERT (*buf == ent->lsda_encoding);
1498 *buf = make_pc_relative (*buf, ptr_size);
1504 if (ent->u.cie.make_per_encoding_relative)
1505 *buf = make_pc_relative (*buf, ptr_size);
1506 per_encoding = *buf++;
1507 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1508 BFD_ASSERT (per_width != 0);
1509 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1510 == ent->u.cie.per_encoding_relative);
1511 if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1513 + ((buf - contents + per_width - 1)
1514 & ~((bfd_size_type) per_width - 1)));
1519 val = read_value (abfd, buf, per_width,
1520 get_DW_EH_PE_signed (per_encoding));
1521 if (ent->u.cie.make_per_encoding_relative)
1522 val -= (sec->output_section->vma
1523 + sec->output_offset
1524 + (buf - contents));
1527 val += (bfd_vma) ent->offset - ent->new_offset;
1528 val -= extra_string + extra_data;
1530 write_value (abfd, buf, val, per_width);
1538 BFD_ASSERT (*buf == ent->fde_encoding);
1539 *buf = make_pc_relative (*buf, ptr_size);
1554 bfd_vma value, address;
1557 struct eh_cie_fde *cie;
1560 cie = ent->u.fde.cie_inf;
1562 value = ((ent->new_offset + sec->output_offset + 4)
1563 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1564 bfd_put_32 (abfd, value, buf);
1566 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1567 value = read_value (abfd, buf, width,
1568 get_DW_EH_PE_signed (ent->fde_encoding));
1572 switch (ent->fde_encoding & 0x70)
1574 case DW_EH_PE_textrel:
1575 BFD_ASSERT (hdr_info == NULL);
1577 case DW_EH_PE_datarel:
1579 switch (abfd->arch_info->arch)
1582 BFD_ASSERT (elf_gp (abfd) != 0);
1583 address += elf_gp (abfd);
1586 (*info->callbacks->einfo)
1587 (_("%P: DW_EH_PE_datarel unspecified"
1588 " for this architecture.\n"));
1592 BFD_ASSERT (htab->hgot != NULL
1593 && ((htab->hgot->root.type
1594 == bfd_link_hash_defined)
1595 || (htab->hgot->root.type
1596 == bfd_link_hash_defweak)));
1598 += (htab->hgot->root.u.def.value
1599 + htab->hgot->root.u.def.section->output_offset
1600 + (htab->hgot->root.u.def.section->output_section
1606 case DW_EH_PE_pcrel:
1607 value += (bfd_vma) ent->offset - ent->new_offset;
1608 address += (sec->output_section->vma
1609 + sec->output_offset
1613 if (ent->make_relative)
1614 value -= (sec->output_section->vma
1615 + sec->output_offset
1616 + ent->new_offset + 8);
1617 write_value (abfd, buf, value, width);
1624 /* The address calculation may overflow, giving us a
1625 value greater than 4G on a 32-bit target when
1626 dwarf_vma is 64-bit. */
1627 if (sizeof (address) > 4 && ptr_size == 4)
1628 address &= 0xffffffff;
1629 hdr_info->array[hdr_info->array_count].initial_loc = address;
1630 hdr_info->array[hdr_info->array_count++].fde
1631 = (sec->output_section->vma
1632 + sec->output_offset
1636 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1637 || cie->u.cie.make_lsda_relative)
1639 buf += ent->lsda_offset;
1640 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1641 value = read_value (abfd, buf, width,
1642 get_DW_EH_PE_signed (ent->lsda_encoding));
1645 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1646 value += (bfd_vma) ent->offset - ent->new_offset;
1647 else if (cie->u.cie.make_lsda_relative)
1648 value -= (sec->output_section->vma
1649 + sec->output_offset
1650 + ent->new_offset + 8 + ent->lsda_offset);
1651 write_value (abfd, buf, value, width);
1654 else if (ent->add_augmentation_size)
1656 /* Skip the PC and length and insert a zero byte for the
1657 augmentation size. */
1659 memmove (buf + 1, buf, end - buf);
1665 /* Adjust DW_CFA_set_loc. */
1669 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1670 new_offset = ent->new_offset + 8
1671 + extra_augmentation_string_bytes (ent)
1672 + extra_augmentation_data_bytes (ent);
1674 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1676 buf = start + ent->set_loc[cnt];
1678 value = read_value (abfd, buf, width,
1679 get_DW_EH_PE_signed (ent->fde_encoding));
1683 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1684 value += (bfd_vma) ent->offset + 8 - new_offset;
1685 if (ent->make_relative)
1686 value -= (sec->output_section->vma
1687 + sec->output_offset
1688 + new_offset + ent->set_loc[cnt]);
1689 write_value (abfd, buf, value, width);
1695 /* We don't align the section to its section alignment since the
1696 runtime library only expects all CIE/FDE records aligned at
1697 the pointer size. _bfd_elf_discard_section_eh_frame should
1698 have padded CIE/FDE records to multiple of pointer size with
1699 size_of_output_cie_fde. */
1700 if ((sec->size % ptr_size) != 0)
1703 /* FIXME: octets_per_byte. */
1704 return bfd_set_section_contents (abfd, sec->output_section,
1705 contents, (file_ptr) sec->output_offset,
1709 /* Helper function used to sort .eh_frame_hdr search table by increasing
1710 VMA of FDE initial location. */
1713 vma_compare (const void *a, const void *b)
1715 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1716 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1717 if (p->initial_loc > q->initial_loc)
1719 if (p->initial_loc < q->initial_loc)
1724 /* Write out .eh_frame_hdr section. This must be called after
1725 _bfd_elf_write_section_eh_frame has been called on all input
1727 .eh_frame_hdr format:
1728 ubyte version (currently 1)
1729 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1731 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1732 number (or DW_EH_PE_omit if there is no
1733 binary search table computed))
1734 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1735 or DW_EH_PE_omit if not present.
1736 DW_EH_PE_datarel is using address of
1737 .eh_frame_hdr section start as base)
1738 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1739 optionally followed by:
1740 [encoded] fde_count (total number of FDEs in .eh_frame section)
1741 fde_count x [encoded] initial_loc, fde
1742 (array of encoded pairs containing
1743 FDE initial_location field and FDE address,
1744 sorted by increasing initial_loc). */
1747 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1749 struct elf_link_hash_table *htab;
1750 struct eh_frame_hdr_info *hdr_info;
1753 asection *eh_frame_sec;
1756 bfd_vma encoded_eh_frame;
1758 htab = elf_hash_table (info);
1759 hdr_info = &htab->eh_info;
1760 sec = hdr_info->hdr_sec;
1764 size = EH_FRAME_HDR_SIZE;
1765 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1766 size += 4 + hdr_info->fde_count * 8;
1767 contents = (bfd_byte *) bfd_malloc (size);
1768 if (contents == NULL)
1771 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1772 if (eh_frame_sec == NULL)
1778 memset (contents, 0, EH_FRAME_HDR_SIZE);
1779 contents[0] = 1; /* Version. */
1780 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1781 (abfd, info, eh_frame_sec, 0, sec, 4,
1782 &encoded_eh_frame); /* .eh_frame offset. */
1784 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1786 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1787 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1791 contents[2] = DW_EH_PE_omit;
1792 contents[3] = DW_EH_PE_omit;
1794 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1796 if (contents[2] != DW_EH_PE_omit)
1800 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1801 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1803 for (i = 0; i < hdr_info->fde_count; i++)
1806 hdr_info->array[i].initial_loc
1807 - sec->output_section->vma,
1808 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1810 hdr_info->array[i].fde - sec->output_section->vma,
1811 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1815 /* FIXME: octets_per_byte. */
1816 retval = bfd_set_section_contents (abfd, sec->output_section,
1817 contents, (file_ptr) sec->output_offset,
1823 /* Return the width of FDE addresses. This is the default implementation. */
1826 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1828 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1831 /* Decide whether we can use a PC-relative encoding within the given
1832 EH frame section. This is the default implementation. */
1835 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1836 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1837 asection *eh_frame_section ATTRIBUTE_UNUSED)
1842 /* Select an encoding for the given address. Preference is given to
1843 PC-relative addressing modes. */
1846 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1847 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1848 asection *osec, bfd_vma offset,
1849 asection *loc_sec, bfd_vma loc_offset,
1852 *encoded = osec->vma + offset -
1853 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1854 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;