1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007
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 2 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, MA 02110-1301, USA. */
26 #include "elf/dwarf2.h"
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;
46 struct eh_cie_fde *cie_inf;
47 unsigned char per_encoding;
48 unsigned char lsda_encoding;
49 unsigned char fde_encoding;
50 unsigned char initial_insn_length;
51 unsigned char make_relative;
52 unsigned char make_lsda_relative;
53 unsigned char initial_instructions[50];
58 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
59 move onto the next byte. Return true on success. */
61 static inline bfd_boolean
62 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
66 *result = *((*iter)++);
70 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
71 Return true it was possible to move LENGTH bytes. */
73 static inline bfd_boolean
74 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
76 if ((bfd_size_type) (end - *iter) < length)
85 /* Move *ITER over an leb128, stopping at END. Return true if the end
86 of the leb128 was found. */
89 skip_leb128 (bfd_byte **iter, bfd_byte *end)
93 if (!read_byte (iter, end, &byte))
99 /* Like skip_leb128, but treat the leb128 as an unsigned value and
100 store it in *VALUE. */
103 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
108 if (!skip_leb128 (iter, end))
114 *value = (*value << 7) | (*--p & 0x7f);
119 /* Like read_uleb128, but for signed values. */
122 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
127 if (!skip_leb128 (iter, end))
131 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
133 *value = (*value << 7) | (*--p & 0x7f);
138 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
141 int get_DW_EH_PE_width (int encoding, int ptr_size)
143 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
145 if ((encoding & 0x60) == 0x60)
148 switch (encoding & 7)
150 case DW_EH_PE_udata2: return 2;
151 case DW_EH_PE_udata4: return 4;
152 case DW_EH_PE_udata8: return 8;
153 case DW_EH_PE_absptr: return ptr_size;
161 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
163 /* Read a width sized value from memory. */
166 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
174 value = bfd_get_signed_16 (abfd, buf);
176 value = bfd_get_16 (abfd, buf);
180 value = bfd_get_signed_32 (abfd, buf);
182 value = bfd_get_32 (abfd, buf);
186 value = bfd_get_signed_64 (abfd, buf);
188 value = bfd_get_64 (abfd, buf);
198 /* Store a width sized value to memory. */
201 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
205 case 2: bfd_put_16 (abfd, value, buf); break;
206 case 4: bfd_put_32 (abfd, value, buf); break;
207 case 8: bfd_put_64 (abfd, value, buf); break;
208 default: BFD_FAIL ();
212 /* Return one if C1 and C2 CIEs can be merged. */
215 cie_eq (const void *e1, const void *e2)
217 const struct cie *c1 = e1;
218 const struct cie *c2 = e2;
220 if (c1->hash == c2->hash
221 && c1->length == c2->length
222 && c1->version == c2->version
223 && c1->local_personality == c2->local_personality
224 && strcmp (c1->augmentation, c2->augmentation) == 0
225 && strcmp (c1->augmentation, "eh") != 0
226 && c1->code_align == c2->code_align
227 && c1->data_align == c2->data_align
228 && c1->ra_column == c2->ra_column
229 && c1->augmentation_size == c2->augmentation_size
230 && memcmp (&c1->personality, &c2->personality,
231 sizeof (c1->personality)) == 0
232 && c1->output_sec == c2->output_sec
233 && c1->per_encoding == c2->per_encoding
234 && c1->lsda_encoding == c2->lsda_encoding
235 && c1->fde_encoding == c2->fde_encoding
236 && c1->initial_insn_length == c2->initial_insn_length
237 && memcmp (c1->initial_instructions,
238 c2->initial_instructions,
239 c1->initial_insn_length) == 0)
246 cie_hash (const void *e)
248 const struct cie *c = e;
253 cie_compute_hash (struct cie *c)
256 h = iterative_hash_object (c->length, h);
257 h = iterative_hash_object (c->version, h);
258 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
259 h = iterative_hash_object (c->code_align, h);
260 h = iterative_hash_object (c->data_align, h);
261 h = iterative_hash_object (c->ra_column, h);
262 h = iterative_hash_object (c->augmentation_size, h);
263 h = iterative_hash_object (c->personality, h);
264 h = iterative_hash_object (c->output_sec, h);
265 h = iterative_hash_object (c->per_encoding, h);
266 h = iterative_hash_object (c->lsda_encoding, h);
267 h = iterative_hash_object (c->fde_encoding, h);
268 h = iterative_hash_object (c->initial_insn_length, h);
269 h = iterative_hash (c->initial_instructions, c->initial_insn_length, h);
274 /* Return the number of extra bytes that we'll be inserting into
275 ENTRY's augmentation string. */
277 static INLINE unsigned int
278 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
280 unsigned int size = 0;
283 if (entry->add_augmentation_size)
285 if (entry->add_fde_encoding)
291 /* Likewise ENTRY's augmentation data. */
293 static INLINE unsigned int
294 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
296 unsigned int size = 0;
299 if (entry->add_augmentation_size)
301 if (entry->add_fde_encoding)
306 if (entry->cie_inf->add_augmentation_size)
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 /* This function is called for each input file before the .eh_frame
434 section is relocated. It discards duplicate CIEs and FDEs for discarded
435 functions. The function returns TRUE iff any entries have been
439 _bfd_elf_discard_section_eh_frame
440 (bfd *abfd, struct bfd_link_info *info, asection *sec,
441 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
442 struct elf_reloc_cookie *cookie)
444 #define REQUIRE(COND) \
447 goto free_no_table; \
450 bfd_byte *ehbuf = NULL, *buf;
452 struct eh_cie_fde *ent, *this_inf;
453 unsigned int hdr_length, hdr_id;
458 unsigned int usage_count;
460 } *ecies = NULL, *ecie;
461 unsigned int ecie_count = 0, ecie_alloced = 0;
463 struct elf_link_hash_table *htab;
464 struct eh_frame_hdr_info *hdr_info;
465 struct eh_frame_sec_info *sec_info = NULL;
467 unsigned int ptr_size;
468 unsigned int entry_alloced;
472 /* This file does not contain .eh_frame information. */
476 if (bfd_is_abs_section (sec->output_section))
478 /* At least one of the sections is being discarded from the
479 link, so we should just ignore them. */
483 htab = elf_hash_table (info);
484 hdr_info = &htab->eh_info;
486 if (hdr_info->cies == NULL && !info->relocatable)
487 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
489 /* Read the frame unwind information from abfd. */
491 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
494 && bfd_get_32 (abfd, ehbuf) == 0
495 && cookie->rel == cookie->relend)
497 /* Empty .eh_frame section. */
502 /* If .eh_frame section size doesn't fit into int, we cannot handle
503 it (it would need to use 64-bit .eh_frame format anyway). */
504 REQUIRE (sec->size == (unsigned int) sec->size);
506 ptr_size = (get_elf_backend_data (abfd)
507 ->elf_backend_eh_frame_address_size (abfd, sec));
508 REQUIRE (ptr_size != 0);
511 sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
512 + 99 * sizeof (struct eh_cie_fde));
517 #define ENSURE_NO_RELOCS(buf) \
518 REQUIRE (!(cookie->rel < cookie->relend \
519 && (cookie->rel->r_offset \
520 < (bfd_size_type) ((buf) - ehbuf)) \
521 && cookie->rel->r_info != 0))
523 #define SKIP_RELOCS(buf) \
524 while (cookie->rel < cookie->relend \
525 && (cookie->rel->r_offset \
526 < (bfd_size_type) ((buf) - ehbuf))) \
529 #define GET_RELOC(buf) \
530 ((cookie->rel < cookie->relend \
531 && (cookie->rel->r_offset \
532 == (bfd_size_type) ((buf) - ehbuf))) \
533 ? cookie->rel : NULL)
538 bfd_byte *start, *end, *insns, *insns_end;
539 bfd_size_type length;
540 unsigned int set_loc_count;
542 if (sec_info->count == entry_alloced)
544 sec_info = bfd_realloc (sec_info,
545 sizeof (struct eh_frame_sec_info)
546 + ((entry_alloced + 99)
547 * sizeof (struct eh_cie_fde)));
550 memset (&sec_info->entry[entry_alloced], 0,
551 100 * sizeof (struct eh_cie_fde));
552 entry_alloced += 100;
555 this_inf = sec_info->entry + sec_info->count;
558 if ((bfd_size_type) (buf - ehbuf) == sec->size)
561 /* Read the length of the entry. */
562 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
563 hdr_length = bfd_get_32 (abfd, buf - 4);
565 /* 64-bit .eh_frame is not supported. */
566 REQUIRE (hdr_length != 0xffffffff);
568 /* The CIE/FDE must be fully contained in this input section. */
569 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
570 end = buf + hdr_length;
572 this_inf->offset = last_fde - ehbuf;
573 this_inf->size = 4 + hdr_length;
577 /* A zero-length CIE should only be found at the end of
579 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
580 ENSURE_NO_RELOCS (buf);
585 REQUIRE (skip_bytes (&buf, end, 4));
586 hdr_id = bfd_get_32 (abfd, buf - 4);
590 unsigned int initial_insn_length;
595 if (ecie_count == ecie_alloced)
597 ecies = bfd_realloc (ecies,
598 (ecie_alloced + 20) * sizeof (*ecies));
600 memset (&ecies[ecie_alloced], 0, 20 * sizeof (*ecies));
604 cie = &ecies[ecie_count].cie;
605 ecies[ecie_count].offset = this_inf->offset;
606 ecies[ecie_count++].entry = sec_info->count;
607 cie->length = hdr_length;
609 REQUIRE (read_byte (&buf, end, &cie->version));
611 /* Cannot handle unknown versions. */
612 REQUIRE (cie->version == 1 || cie->version == 3);
613 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
615 strcpy (cie->augmentation, (char *) buf);
616 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
617 ENSURE_NO_RELOCS (buf);
618 if (buf[0] == 'e' && buf[1] == 'h')
620 /* GCC < 3.0 .eh_frame CIE */
621 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
622 is private to each CIE, so we don't need it for anything.
624 REQUIRE (skip_bytes (&buf, end, ptr_size));
627 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
628 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
629 if (cie->version == 1)
632 cie->ra_column = *buf++;
635 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
636 ENSURE_NO_RELOCS (buf);
637 cie->lsda_encoding = DW_EH_PE_omit;
638 cie->fde_encoding = DW_EH_PE_omit;
639 cie->per_encoding = DW_EH_PE_omit;
640 aug = cie->augmentation;
641 if (aug[0] != 'e' || aug[1] != 'h')
646 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
647 ENSURE_NO_RELOCS (buf);
654 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
655 ENSURE_NO_RELOCS (buf);
656 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
659 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
660 ENSURE_NO_RELOCS (buf);
661 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
669 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
670 per_width = get_DW_EH_PE_width (cie->per_encoding,
673 if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
675 length = -(buf - ehbuf) & (per_width - 1);
676 REQUIRE (skip_bytes (&buf, end, length));
678 ENSURE_NO_RELOCS (buf);
679 /* Ensure we have a reloc here. */
680 if (GET_RELOC (buf) != NULL)
682 unsigned long r_symndx;
686 r_symndx = ELF64_R_SYM (cookie->rel->r_info);
689 r_symndx = ELF32_R_SYM (cookie->rel->r_info);
690 if (r_symndx >= cookie->locsymcount
691 || ELF_ST_BIND (cookie->locsyms[r_symndx]
692 .st_info) != STB_LOCAL)
694 struct elf_link_hash_entry *h;
696 r_symndx -= cookie->extsymoff;
697 h = cookie->sym_hashes[r_symndx];
699 while (h->root.type == bfd_link_hash_indirect
700 || h->root.type == bfd_link_hash_warning)
701 h = (struct elf_link_hash_entry *)
704 cie->personality.h = h;
708 Elf_Internal_Sym *sym;
712 sym = &cookie->locsyms[r_symndx];
713 sym_sec = (bfd_section_from_elf_index
714 (abfd, sym->st_shndx));
717 if (sym_sec->kept_section != NULL)
718 sym_sec = sym_sec->kept_section;
719 if (sym_sec->output_section != NULL)
722 + sym_sec->output_offset
723 + sym_sec->output_section->vma);
724 cie->personality.val = val;
725 cie->local_personality = 1;
730 /* Cope with MIPS-style composite relocations. */
733 while (GET_RELOC (buf) != NULL);
735 REQUIRE (skip_bytes (&buf, end, per_width));
736 REQUIRE (cie->local_personality || cie->personality.h);
740 /* Unrecognized augmentation. Better bail out. */
745 /* For shared libraries, try to get rid of as many RELATIVE relocs
748 && (get_elf_backend_data (abfd)
749 ->elf_backend_can_make_relative_eh_frame
752 if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
753 cie->make_relative = 1;
754 /* If the CIE doesn't already have an 'R' entry, it's fairly
755 easy to add one, provided that there's no aligned data
756 after the augmentation string. */
757 else if (cie->fde_encoding == DW_EH_PE_omit
758 && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
760 if (*cie->augmentation == 0)
761 this_inf->add_augmentation_size = 1;
762 this_inf->add_fde_encoding = 1;
763 cie->make_relative = 1;
768 && (get_elf_backend_data (abfd)
769 ->elf_backend_can_make_lsda_relative_eh_frame
771 && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
772 cie->make_lsda_relative = 1;
774 /* If FDE encoding was not specified, it defaults to
776 if (cie->fde_encoding == DW_EH_PE_omit)
777 cie->fde_encoding = DW_EH_PE_absptr;
779 initial_insn_length = end - buf;
780 if (initial_insn_length <= sizeof (cie->initial_instructions))
782 cie->initial_insn_length = initial_insn_length;
783 memcpy (cie->initial_instructions, buf, initial_insn_length);
786 buf += initial_insn_length;
787 ENSURE_NO_RELOCS (buf);
791 /* Find the corresponding CIE. */
792 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
793 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
794 if (cie_offset == ecie->offset)
797 /* Ensure this FDE references one of the CIEs in this input
799 REQUIRE (ecie != ecies + ecie_count);
802 ENSURE_NO_RELOCS (buf);
803 REQUIRE (GET_RELOC (buf));
805 if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
806 /* This is a FDE against a discarded section. It should
808 this_inf->removed = 1;
812 && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
813 && cie->make_relative == 0)
814 || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
816 /* If a shared library uses absolute pointers
817 which we cannot turn into PC relative,
818 don't create the binary search table,
819 since it is affected by runtime relocations. */
820 hdr_info->table = FALSE;
821 (*info->callbacks->einfo)
822 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
823 " table being created.\n"), abfd, sec);
826 hdr_info->fde_count++;
827 this_inf->cie_inf = (void *) (ecie - ecies);
830 /* Skip the initial location and address range. */
832 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
833 REQUIRE (skip_bytes (&buf, end, 2 * length));
835 /* Skip the augmentation size, if present. */
836 if (cie->augmentation[0] == 'z')
837 REQUIRE (read_uleb128 (&buf, end, &length));
841 /* Of the supported augmentation characters above, only 'L'
842 adds augmentation data to the FDE. This code would need to
843 be adjusted if any future augmentations do the same thing. */
844 if (cie->lsda_encoding != DW_EH_PE_omit)
846 this_inf->lsda_offset = buf - start;
847 /* If there's no 'z' augmentation, we don't know where the
848 CFA insns begin. Assume no padding. */
849 if (cie->augmentation[0] != 'z')
853 /* Skip over the augmentation data. */
854 REQUIRE (skip_bytes (&buf, end, length));
857 buf = last_fde + 4 + hdr_length;
861 /* Try to interpret the CFA instructions and find the first
862 padding nop. Shrink this_inf's size so that it doesn't
863 include the padding. */
864 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
866 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
867 /* If we don't understand the CFA instructions, we can't know
868 what needs to be adjusted there. */
869 if (insns_end == NULL
870 /* For the time being we don't support DW_CFA_set_loc in
872 || (set_loc_count && this_inf->cie))
874 this_inf->size -= end - insns_end;
875 if (insns_end != end && this_inf->cie)
877 cie->initial_insn_length -= end - insns_end;
878 cie->length -= end - insns_end;
881 && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
882 || cie->make_relative))
887 this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
888 * sizeof (unsigned int));
889 REQUIRE (this_inf->set_loc);
890 this_inf->set_loc[0] = set_loc_count;
895 if (*p == DW_CFA_set_loc)
896 this_inf->set_loc[++cnt] = p + 1 - start;
897 REQUIRE (skip_cfa_op (&p, end, length));
901 this_inf->fde_encoding = cie->fde_encoding;
902 this_inf->lsda_encoding = cie->lsda_encoding;
906 elf_section_data (sec)->sec_info = sec_info;
907 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
909 /* Look at all CIEs in this section and determine which can be
910 removed as unused, which can be merged with previous duplicate
911 CIEs and which need to be kept. */
912 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
914 if (ecie->usage_count == 0)
916 sec_info->entry[ecie->entry].removed = 1;
919 ecie->cie.output_sec = sec->output_section;
920 ecie->cie.cie_inf = sec_info->entry + ecie->entry;
921 cie_compute_hash (&ecie->cie);
922 if (hdr_info->cies != NULL)
924 void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
925 ecie->cie.hash, INSERT);
928 if (*loc != HTAB_EMPTY_ENTRY)
930 sec_info->entry[ecie->entry].removed = 1;
931 ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
935 *loc = malloc (sizeof (struct cie));
937 *loc = HTAB_DELETED_ENTRY;
939 memcpy (*loc, &ecie->cie, sizeof (struct cie));
942 ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
943 ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
944 ecie->cie.cie_inf->per_encoding_relative
945 = (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
948 /* Ok, now we can assign new offsets. */
950 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
955 ecie = ecies + (unsigned long) ent->cie_inf;
956 ent->cie_inf = ecie->cie.cie_inf;
958 ent->new_offset = offset;
959 offset += size_of_output_cie_fde (ent, ptr_size);
962 /* Resize the sec as needed. */
963 sec->rawsize = sec->size;
969 return offset != sec->rawsize;
972 (*info->callbacks->einfo)
973 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
981 hdr_info->table = FALSE;
987 /* This function is called for .eh_frame_hdr section after
988 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
989 input sections. It finalizes the size of .eh_frame_hdr section. */
992 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
994 struct elf_link_hash_table *htab;
995 struct eh_frame_hdr_info *hdr_info;
998 htab = elf_hash_table (info);
999 hdr_info = &htab->eh_info;
1001 if (hdr_info->cies != NULL)
1003 htab_delete (hdr_info->cies);
1004 hdr_info->cies = NULL;
1007 sec = hdr_info->hdr_sec;
1011 sec->size = EH_FRAME_HDR_SIZE;
1012 if (hdr_info->table)
1013 sec->size += 4 + hdr_info->fde_count * 8;
1015 elf_tdata (abfd)->eh_frame_hdr = sec;
1019 /* This function is called from size_dynamic_sections.
1020 It needs to decide whether .eh_frame_hdr should be output or not,
1021 because when the dynamic symbol table has been sized it is too late
1022 to strip sections. */
1025 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1029 struct elf_link_hash_table *htab;
1030 struct eh_frame_hdr_info *hdr_info;
1032 htab = elf_hash_table (info);
1033 hdr_info = &htab->eh_info;
1034 if (hdr_info->hdr_sec == NULL)
1037 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1039 hdr_info->hdr_sec = NULL;
1044 if (info->eh_frame_hdr)
1045 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1047 /* Count only sections which have at least a single CIE or FDE.
1048 There cannot be any CIE or FDE <= 8 bytes. */
1049 o = bfd_get_section_by_name (abfd, ".eh_frame");
1050 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1056 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1057 hdr_info->hdr_sec = NULL;
1061 hdr_info->table = TRUE;
1065 /* Adjust an address in the .eh_frame section. Given OFFSET within
1066 SEC, this returns the new offset in the adjusted .eh_frame section,
1067 or -1 if the address refers to a CIE/FDE which has been removed
1068 or to offset with dynamic relocation which is no longer needed. */
1071 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1072 struct bfd_link_info *info,
1076 struct eh_frame_sec_info *sec_info;
1077 struct elf_link_hash_table *htab;
1078 struct eh_frame_hdr_info *hdr_info;
1079 unsigned int lo, hi, mid;
1081 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1083 sec_info = elf_section_data (sec)->sec_info;
1085 if (offset >= sec->rawsize)
1086 return offset - sec->rawsize + sec->size;
1088 htab = elf_hash_table (info);
1089 hdr_info = &htab->eh_info;
1090 if (hdr_info->offsets_adjusted)
1091 offset += sec->output_offset;
1094 hi = sec_info->count;
1098 mid = (lo + hi) / 2;
1099 if (offset < sec_info->entry[mid].offset)
1102 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1108 BFD_ASSERT (lo < hi);
1110 /* FDE or CIE was removed. */
1111 if (sec_info->entry[mid].removed)
1112 return (bfd_vma) -1;
1114 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1115 relocation against FDE's initial_location field. */
1116 if (!sec_info->entry[mid].cie
1117 && sec_info->entry[mid].cie_inf->make_relative
1118 && offset == sec_info->entry[mid].offset + 8)
1119 return (bfd_vma) -2;
1121 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1122 for run-time relocation against LSDA field. */
1123 if (!sec_info->entry[mid].cie
1124 && sec_info->entry[mid].cie_inf->make_lsda_relative
1125 && (offset == (sec_info->entry[mid].offset + 8
1126 + sec_info->entry[mid].lsda_offset))
1127 && (sec_info->entry[mid].cie_inf->need_lsda_relative
1128 || !hdr_info->offsets_adjusted))
1130 sec_info->entry[mid].cie_inf->need_lsda_relative = 1;
1131 return (bfd_vma) -2;
1134 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1135 relocation against DW_CFA_set_loc's arguments. */
1136 if (sec_info->entry[mid].set_loc
1137 && (sec_info->entry[mid].cie
1138 ? sec_info->entry[mid].make_relative
1139 : sec_info->entry[mid].cie_inf->make_relative)
1140 && (offset >= sec_info->entry[mid].offset + 8
1141 + sec_info->entry[mid].set_loc[1]))
1145 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1146 if (offset == sec_info->entry[mid].offset + 8
1147 + sec_info->entry[mid].set_loc[cnt])
1148 return (bfd_vma) -2;
1151 if (hdr_info->offsets_adjusted)
1152 offset -= sec->output_offset;
1153 /* Any new augmentation bytes go before the first relocation. */
1154 return (offset + sec_info->entry[mid].new_offset
1155 - sec_info->entry[mid].offset
1156 + extra_augmentation_string_bytes (sec_info->entry + mid)
1157 + extra_augmentation_data_bytes (sec_info->entry + mid));
1160 /* Write out .eh_frame section. This is called with the relocated
1164 _bfd_elf_write_section_eh_frame (bfd *abfd,
1165 struct bfd_link_info *info,
1169 struct eh_frame_sec_info *sec_info;
1170 struct elf_link_hash_table *htab;
1171 struct eh_frame_hdr_info *hdr_info;
1172 unsigned int ptr_size;
1173 struct eh_cie_fde *ent;
1175 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1176 return bfd_set_section_contents (abfd, sec->output_section, contents,
1177 sec->output_offset, sec->size);
1179 ptr_size = (get_elf_backend_data (abfd)
1180 ->elf_backend_eh_frame_address_size (abfd, sec));
1181 BFD_ASSERT (ptr_size != 0);
1183 sec_info = elf_section_data (sec)->sec_info;
1184 htab = elf_hash_table (info);
1185 hdr_info = &htab->eh_info;
1187 /* First convert all offsets to output section offsets, so that a
1188 CIE offset is valid if the CIE is used by a FDE from some other
1189 section. This can happen when duplicate CIEs are deleted in
1190 _bfd_elf_discard_section_eh_frame. We do all sections here because
1191 this function might not be called on sections in the same order as
1192 _bfd_elf_discard_section_eh_frame. */
1193 if (!hdr_info->offsets_adjusted)
1197 struct eh_frame_sec_info *eh_inf;
1199 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1201 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1202 || (ibfd->flags & DYNAMIC) != 0)
1205 eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1206 if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1209 eh_inf = elf_section_data (eh)->sec_info;
1210 for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1212 ent->offset += eh->output_offset;
1213 ent->new_offset += eh->output_offset;
1216 hdr_info->offsets_adjusted = TRUE;
1219 if (hdr_info->table && hdr_info->array == NULL)
1221 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1222 if (hdr_info->array == NULL)
1225 /* The new offsets can be bigger or smaller than the original offsets.
1226 We therefore need to make two passes over the section: one backward
1227 pass to move entries up and one forward pass to move entries down.
1228 The two passes won't interfere with each other because entries are
1230 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1231 if (!ent->removed && ent->new_offset > ent->offset)
1232 memmove (contents + ent->new_offset - sec->output_offset,
1233 contents + ent->offset - sec->output_offset, ent->size);
1235 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1236 if (!ent->removed && ent->new_offset < ent->offset)
1237 memmove (contents + ent->new_offset - sec->output_offset,
1238 contents + ent->offset - sec->output_offset, ent->size);
1240 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1242 unsigned char *buf, *end;
1243 unsigned int new_size;
1250 /* Any terminating FDE must be at the end of the section. */
1251 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1255 buf = contents + ent->new_offset - sec->output_offset;
1256 end = buf + ent->size;
1257 new_size = size_of_output_cie_fde (ent, ptr_size);
1259 /* Update the size. It may be shrinked. */
1260 bfd_put_32 (abfd, new_size - 4, buf);
1262 /* Filling the extra bytes with DW_CFA_nops. */
1263 if (new_size != ent->size)
1264 memset (end, 0, new_size - ent->size);
1269 if (ent->make_relative
1270 || ent->need_lsda_relative
1271 || ent->per_encoding_relative)
1274 unsigned int action, extra_string, extra_data;
1275 unsigned int per_width, per_encoding;
1277 /* Need to find 'R' or 'L' augmentation's argument and modify
1278 DW_EH_PE_* value. */
1279 action = ((ent->make_relative ? 1 : 0)
1280 | (ent->need_lsda_relative ? 2 : 0)
1281 | (ent->per_encoding_relative ? 4 : 0));
1282 extra_string = extra_augmentation_string_bytes (ent);
1283 extra_data = extra_augmentation_data_bytes (ent);
1285 /* Skip length, id and version. */
1288 buf += strlen (aug) + 1;
1289 skip_leb128 (&buf, end);
1290 skip_leb128 (&buf, end);
1291 skip_leb128 (&buf, end);
1294 /* The uleb128 will always be a single byte for the kind
1295 of augmentation strings that we're prepared to handle. */
1296 *buf++ += extra_data;
1300 /* Make room for the new augmentation string and data bytes. */
1301 memmove (buf + extra_string + extra_data, buf, end - buf);
1302 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1303 buf += extra_string;
1304 end += extra_string + extra_data;
1306 if (ent->add_augmentation_size)
1309 *buf++ = extra_data - 1;
1311 if (ent->add_fde_encoding)
1313 BFD_ASSERT (action & 1);
1315 *buf++ = DW_EH_PE_pcrel;
1325 BFD_ASSERT (*buf == ent->lsda_encoding);
1326 *buf |= DW_EH_PE_pcrel;
1332 per_encoding = *buf++;
1333 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1334 BFD_ASSERT (per_width != 0);
1335 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1336 == ent->per_encoding_relative);
1337 if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1339 + ((buf - contents + per_width - 1)
1340 & ~((bfd_size_type) per_width - 1)));
1345 val = read_value (abfd, buf, per_width,
1346 get_DW_EH_PE_signed (per_encoding));
1347 val += ent->offset - ent->new_offset;
1348 val -= extra_string + extra_data;
1349 write_value (abfd, buf, val, per_width);
1357 BFD_ASSERT (*buf == ent->fde_encoding);
1358 *buf |= DW_EH_PE_pcrel;
1373 bfd_vma value, address;
1379 value = ent->new_offset + 4 - ent->cie_inf->new_offset;
1380 bfd_put_32 (abfd, value, buf);
1382 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1383 value = read_value (abfd, buf, width,
1384 get_DW_EH_PE_signed (ent->fde_encoding));
1388 switch (ent->fde_encoding & 0xf0)
1390 case DW_EH_PE_indirect:
1391 case DW_EH_PE_textrel:
1392 BFD_ASSERT (hdr_info == NULL);
1394 case DW_EH_PE_datarel:
1396 asection *got = bfd_get_section_by_name (abfd, ".got");
1398 BFD_ASSERT (got != NULL);
1399 address += got->vma;
1402 case DW_EH_PE_pcrel:
1403 value += ent->offset - ent->new_offset;
1404 address += sec->output_section->vma + ent->offset + 8;
1407 if (ent->cie_inf->make_relative)
1408 value -= sec->output_section->vma + ent->new_offset + 8;
1409 write_value (abfd, buf, value, width);
1416 hdr_info->array[hdr_info->array_count].initial_loc = address;
1417 hdr_info->array[hdr_info->array_count++].fde
1418 = sec->output_section->vma + ent->new_offset;
1421 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1422 || ent->cie_inf->need_lsda_relative)
1424 buf += ent->lsda_offset;
1425 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1426 value = read_value (abfd, buf, width,
1427 get_DW_EH_PE_signed (ent->lsda_encoding));
1430 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1431 value += ent->offset - ent->new_offset;
1432 else if (ent->cie_inf->need_lsda_relative)
1433 value -= (sec->output_section->vma + ent->new_offset + 8
1434 + ent->lsda_offset);
1435 write_value (abfd, buf, value, width);
1438 else if (ent->cie_inf->add_augmentation_size)
1440 /* Skip the PC and length and insert a zero byte for the
1441 augmentation size. */
1443 memmove (buf + 1, buf, end - buf);
1449 /* Adjust DW_CFA_set_loc. */
1450 unsigned int cnt, width;
1453 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1454 new_offset = ent->new_offset + 8
1455 + extra_augmentation_string_bytes (ent)
1456 + extra_augmentation_data_bytes (ent);
1458 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1461 buf = start + ent->set_loc[cnt];
1463 value = read_value (abfd, buf, width,
1464 get_DW_EH_PE_signed (ent->fde_encoding));
1468 if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1469 value += ent->offset + 8 - new_offset;
1470 if (ent->cie_inf->make_relative)
1471 value -= sec->output_section->vma + new_offset
1472 + ent->set_loc[cnt];
1473 write_value (abfd, buf, value, width);
1479 /* We don't align the section to its section alignment since the
1480 runtime library only expects all CIE/FDE records aligned at
1481 the pointer size. _bfd_elf_discard_section_eh_frame should
1482 have padded CIE/FDE records to multiple of pointer size with
1483 size_of_output_cie_fde. */
1484 if ((sec->size % ptr_size) != 0)
1487 return bfd_set_section_contents (abfd, sec->output_section,
1488 contents, (file_ptr) sec->output_offset,
1492 /* Helper function used to sort .eh_frame_hdr search table by increasing
1493 VMA of FDE initial location. */
1496 vma_compare (const void *a, const void *b)
1498 const struct eh_frame_array_ent *p = a;
1499 const struct eh_frame_array_ent *q = b;
1500 if (p->initial_loc > q->initial_loc)
1502 if (p->initial_loc < q->initial_loc)
1507 /* Write out .eh_frame_hdr section. This must be called after
1508 _bfd_elf_write_section_eh_frame has been called on all input
1510 .eh_frame_hdr format:
1511 ubyte version (currently 1)
1512 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1514 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1515 number (or DW_EH_PE_omit if there is no
1516 binary search table computed))
1517 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1518 or DW_EH_PE_omit if not present.
1519 DW_EH_PE_datarel is using address of
1520 .eh_frame_hdr section start as base)
1521 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1522 optionally followed by:
1523 [encoded] fde_count (total number of FDEs in .eh_frame section)
1524 fde_count x [encoded] initial_loc, fde
1525 (array of encoded pairs containing
1526 FDE initial_location field and FDE address,
1527 sorted by increasing initial_loc). */
1530 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1532 struct elf_link_hash_table *htab;
1533 struct eh_frame_hdr_info *hdr_info;
1536 asection *eh_frame_sec;
1539 bfd_vma encoded_eh_frame;
1541 htab = elf_hash_table (info);
1542 hdr_info = &htab->eh_info;
1543 sec = hdr_info->hdr_sec;
1547 size = EH_FRAME_HDR_SIZE;
1548 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1549 size += 4 + hdr_info->fde_count * 8;
1550 contents = bfd_malloc (size);
1551 if (contents == NULL)
1554 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1555 if (eh_frame_sec == NULL)
1561 memset (contents, 0, EH_FRAME_HDR_SIZE);
1562 contents[0] = 1; /* Version. */
1563 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1564 (abfd, info, eh_frame_sec, 0, sec, 4,
1565 &encoded_eh_frame); /* .eh_frame offset. */
1567 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1569 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1570 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1574 contents[2] = DW_EH_PE_omit;
1575 contents[3] = DW_EH_PE_omit;
1577 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1579 if (contents[2] != DW_EH_PE_omit)
1583 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1584 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1586 for (i = 0; i < hdr_info->fde_count; i++)
1589 hdr_info->array[i].initial_loc
1590 - sec->output_section->vma,
1591 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1593 hdr_info->array[i].fde - sec->output_section->vma,
1594 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1598 retval = bfd_set_section_contents (abfd, sec->output_section,
1599 contents, (file_ptr) sec->output_offset,
1605 /* Return the width of FDE addresses. This is the default implementation. */
1608 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1610 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1613 /* Decide whether we can use a PC-relative encoding within the given
1614 EH frame section. This is the default implementation. */
1617 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1618 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1619 asection *eh_frame_section ATTRIBUTE_UNUSED)
1624 /* Select an encoding for the given address. Preference is given to
1625 PC-relative addressing modes. */
1628 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1629 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1630 asection *osec, bfd_vma offset,
1631 asection *loc_sec, bfd_vma loc_offset,
1634 *encoded = osec->vma + offset -
1635 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1636 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;