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 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. */
27 #include "elf/dwarf2.h"
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;
47 struct eh_cie_fde *cie_inf;
48 unsigned char per_encoding;
49 unsigned char lsda_encoding;
50 unsigned char fde_encoding;
51 unsigned char initial_insn_length;
52 unsigned char make_relative;
53 unsigned char 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 = e1;
219 const struct cie *c2 = 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 = 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->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;
300 if (entry->add_augmentation_size)
302 if (entry->add_fde_encoding)
307 if (entry->u.fde.cie_inf->add_augmentation_size)
313 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
314 required alignment of ENTRY in bytes. */
317 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
321 if (entry->size == 4)
324 + extra_augmentation_string_bytes (entry)
325 + extra_augmentation_data_bytes (entry)
326 + alignment - 1) & -alignment;
329 /* Assume that the bytes between *ITER and END are CFA instructions.
330 Try to move *ITER past the first instruction and return true on
331 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
334 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
339 if (!read_byte (iter, end, &op))
342 switch (op & 0xc0 ? op & 0xc0 : op)
345 case DW_CFA_advance_loc:
347 case DW_CFA_remember_state:
348 case DW_CFA_restore_state:
349 case DW_CFA_GNU_window_save:
354 case DW_CFA_restore_extended:
355 case DW_CFA_undefined:
356 case DW_CFA_same_value:
357 case DW_CFA_def_cfa_register:
358 case DW_CFA_def_cfa_offset:
359 case DW_CFA_def_cfa_offset_sf:
360 case DW_CFA_GNU_args_size:
361 /* One leb128 argument. */
362 return skip_leb128 (iter, end);
364 case DW_CFA_val_offset:
365 case DW_CFA_val_offset_sf:
366 case DW_CFA_offset_extended:
367 case DW_CFA_register:
369 case DW_CFA_offset_extended_sf:
370 case DW_CFA_GNU_negative_offset_extended:
371 case DW_CFA_def_cfa_sf:
372 /* Two leb128 arguments. */
373 return (skip_leb128 (iter, end)
374 && skip_leb128 (iter, end));
376 case DW_CFA_def_cfa_expression:
377 /* A variable-length argument. */
378 return (read_uleb128 (iter, end, &length)
379 && skip_bytes (iter, end, length));
381 case DW_CFA_expression:
382 case DW_CFA_val_expression:
383 /* A leb128 followed by a variable-length argument. */
384 return (skip_leb128 (iter, end)
385 && read_uleb128 (iter, end, &length)
386 && skip_bytes (iter, end, length));
389 return skip_bytes (iter, end, encoded_ptr_width);
391 case DW_CFA_advance_loc1:
392 return skip_bytes (iter, end, 1);
394 case DW_CFA_advance_loc2:
395 return skip_bytes (iter, end, 2);
397 case DW_CFA_advance_loc4:
398 return skip_bytes (iter, end, 4);
400 case DW_CFA_MIPS_advance_loc8:
401 return skip_bytes (iter, end, 8);
408 /* Try to interpret the bytes between BUF and END as CFA instructions.
409 If every byte makes sense, return a pointer to the first DW_CFA_nop
410 padding byte, or END if there is no padding. Return null otherwise.
411 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
414 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
415 unsigned int *set_loc_count)
421 if (*buf == DW_CFA_nop)
425 if (*buf == DW_CFA_set_loc)
427 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
434 /* This function is called for each input file before the .eh_frame
435 section is relocated. It discards duplicate CIEs and FDEs for discarded
436 functions. The function returns TRUE iff any entries have been
440 _bfd_elf_discard_section_eh_frame
441 (bfd *abfd, struct bfd_link_info *info, asection *sec,
442 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
443 struct elf_reloc_cookie *cookie)
445 #define REQUIRE(COND) \
448 goto free_no_table; \
451 bfd_byte *ehbuf = NULL, *buf;
453 struct eh_cie_fde *ent, *this_inf;
454 unsigned int hdr_length, hdr_id;
459 unsigned int usage_count;
461 } *ecies = NULL, *ecie;
462 unsigned int ecie_count = 0, ecie_alloced = 0;
464 struct elf_link_hash_table *htab;
465 struct eh_frame_hdr_info *hdr_info;
466 struct eh_frame_sec_info *sec_info = NULL;
468 unsigned int ptr_size;
469 unsigned int entry_alloced;
473 /* This file does not contain .eh_frame information. */
477 if (bfd_is_abs_section (sec->output_section))
479 /* At least one of the sections is being discarded from the
480 link, so we should just ignore them. */
484 htab = elf_hash_table (info);
485 hdr_info = &htab->eh_info;
487 if (hdr_info->cies == NULL && !info->relocatable)
488 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
490 /* Read the frame unwind information from abfd. */
492 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
495 && bfd_get_32 (abfd, ehbuf) == 0
496 && cookie->rel == cookie->relend)
498 /* Empty .eh_frame section. */
503 /* If .eh_frame section size doesn't fit into int, we cannot handle
504 it (it would need to use 64-bit .eh_frame format anyway). */
505 REQUIRE (sec->size == (unsigned int) sec->size);
507 ptr_size = (get_elf_backend_data (abfd)
508 ->elf_backend_eh_frame_address_size (abfd, sec));
509 REQUIRE (ptr_size != 0);
512 sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
513 + 99 * sizeof (struct eh_cie_fde));
518 #define ENSURE_NO_RELOCS(buf) \
519 REQUIRE (!(cookie->rel < cookie->relend \
520 && (cookie->rel->r_offset \
521 < (bfd_size_type) ((buf) - ehbuf)) \
522 && cookie->rel->r_info != 0))
524 #define SKIP_RELOCS(buf) \
525 while (cookie->rel < cookie->relend \
526 && (cookie->rel->r_offset \
527 < (bfd_size_type) ((buf) - ehbuf))) \
530 #define GET_RELOC(buf) \
531 ((cookie->rel < cookie->relend \
532 && (cookie->rel->r_offset \
533 == (bfd_size_type) ((buf) - ehbuf))) \
534 ? cookie->rel : NULL)
539 bfd_byte *start, *end, *insns, *insns_end;
540 bfd_size_type length;
541 unsigned int set_loc_count;
543 if (sec_info->count == entry_alloced)
545 sec_info = bfd_realloc (sec_info,
546 sizeof (struct eh_frame_sec_info)
547 + ((entry_alloced + 99)
548 * sizeof (struct eh_cie_fde)));
551 memset (&sec_info->entry[entry_alloced], 0,
552 100 * sizeof (struct eh_cie_fde));
553 entry_alloced += 100;
556 this_inf = sec_info->entry + sec_info->count;
559 if ((bfd_size_type) (buf - ehbuf) == sec->size)
562 /* Read the length of the entry. */
563 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
564 hdr_length = bfd_get_32 (abfd, buf - 4);
566 /* 64-bit .eh_frame is not supported. */
567 REQUIRE (hdr_length != 0xffffffff);
569 /* The CIE/FDE must be fully contained in this input section. */
570 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
571 end = buf + hdr_length;
573 this_inf->offset = last_fde - ehbuf;
574 this_inf->size = 4 + hdr_length;
575 this_inf->reloc_index = cookie->rel - cookie->rels;
579 /* A zero-length CIE should only be found at the end of
581 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
582 ENSURE_NO_RELOCS (buf);
587 REQUIRE (skip_bytes (&buf, end, 4));
588 hdr_id = bfd_get_32 (abfd, buf - 4);
592 unsigned int initial_insn_length;
597 if (ecie_count == ecie_alloced)
599 ecies = bfd_realloc (ecies,
600 (ecie_alloced + 20) * sizeof (*ecies));
602 memset (&ecies[ecie_alloced], 0, 20 * sizeof (*ecies));
606 cie = &ecies[ecie_count].cie;
607 ecies[ecie_count].offset = this_inf->offset;
608 ecies[ecie_count++].entry = sec_info->count;
609 cie->length = hdr_length;
611 REQUIRE (read_byte (&buf, end, &cie->version));
613 /* Cannot handle unknown versions. */
614 REQUIRE (cie->version == 1 || cie->version == 3);
615 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
617 strcpy (cie->augmentation, (char *) buf);
618 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
619 ENSURE_NO_RELOCS (buf);
620 if (buf[0] == 'e' && buf[1] == 'h')
622 /* GCC < 3.0 .eh_frame CIE */
623 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
624 is private to each CIE, so we don't need it for anything.
626 REQUIRE (skip_bytes (&buf, end, ptr_size));
629 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
630 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
631 if (cie->version == 1)
634 cie->ra_column = *buf++;
637 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
638 ENSURE_NO_RELOCS (buf);
639 cie->lsda_encoding = DW_EH_PE_omit;
640 cie->fde_encoding = DW_EH_PE_omit;
641 cie->per_encoding = DW_EH_PE_omit;
642 aug = cie->augmentation;
643 if (aug[0] != 'e' || aug[1] != 'h')
648 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
649 ENSURE_NO_RELOCS (buf);
656 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
657 ENSURE_NO_RELOCS (buf);
658 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
661 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
662 ENSURE_NO_RELOCS (buf);
663 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
671 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
672 per_width = get_DW_EH_PE_width (cie->per_encoding,
675 if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
677 length = -(buf - ehbuf) & (per_width - 1);
678 REQUIRE (skip_bytes (&buf, end, length));
680 ENSURE_NO_RELOCS (buf);
681 /* Ensure we have a reloc here. */
682 if (GET_RELOC (buf) != NULL)
684 unsigned long r_symndx;
687 if (elf_elfheader (abfd)->e_ident[EI_CLASS]
689 r_symndx = ELF64_R_SYM (cookie->rel->r_info);
692 r_symndx = ELF32_R_SYM (cookie->rel->r_info);
693 if (r_symndx >= cookie->locsymcount
694 || ELF_ST_BIND (cookie->locsyms[r_symndx]
695 .st_info) != STB_LOCAL)
697 struct elf_link_hash_entry *h;
699 r_symndx -= cookie->extsymoff;
700 h = cookie->sym_hashes[r_symndx];
702 while (h->root.type == bfd_link_hash_indirect
703 || h->root.type == bfd_link_hash_warning)
704 h = (struct elf_link_hash_entry *)
707 cie->personality.h = h;
711 Elf_Internal_Sym *sym;
715 sym = &cookie->locsyms[r_symndx];
716 sym_sec = (bfd_section_from_elf_index
717 (abfd, sym->st_shndx));
720 if (sym_sec->kept_section != NULL)
721 sym_sec = sym_sec->kept_section;
722 if (sym_sec->output_section != NULL)
725 + sym_sec->output_offset
726 + sym_sec->output_section->vma);
727 cie->personality.val = val;
728 cie->local_personality = 1;
733 /* Cope with MIPS-style composite relocations. */
736 while (GET_RELOC (buf) != NULL);
738 REQUIRE (skip_bytes (&buf, end, per_width));
739 REQUIRE (cie->local_personality || cie->personality.h);
743 /* Unrecognized augmentation. Better bail out. */
748 /* For shared libraries, try to get rid of as many RELATIVE relocs
751 && (get_elf_backend_data (abfd)
752 ->elf_backend_can_make_relative_eh_frame
755 if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
756 cie->make_relative = 1;
757 /* If the CIE doesn't already have an 'R' entry, it's fairly
758 easy to add one, provided that there's no aligned data
759 after the augmentation string. */
760 else if (cie->fde_encoding == DW_EH_PE_omit
761 && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
763 if (*cie->augmentation == 0)
764 this_inf->add_augmentation_size = 1;
765 this_inf->add_fde_encoding = 1;
766 cie->make_relative = 1;
771 && (get_elf_backend_data (abfd)
772 ->elf_backend_can_make_lsda_relative_eh_frame
774 && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
775 cie->make_lsda_relative = 1;
777 /* If FDE encoding was not specified, it defaults to
779 if (cie->fde_encoding == DW_EH_PE_omit)
780 cie->fde_encoding = DW_EH_PE_absptr;
782 initial_insn_length = end - buf;
783 if (initial_insn_length <= sizeof (cie->initial_instructions))
785 cie->initial_insn_length = initial_insn_length;
786 memcpy (cie->initial_instructions, buf, initial_insn_length);
789 buf += initial_insn_length;
790 ENSURE_NO_RELOCS (buf);
794 /* Find the corresponding CIE. */
795 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
796 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
797 if (cie_offset == ecie->offset)
800 /* Ensure this FDE references one of the CIEs in this input
802 REQUIRE (ecie != ecies + ecie_count);
805 ENSURE_NO_RELOCS (buf);
806 REQUIRE (GET_RELOC (buf));
808 if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
809 /* This is a FDE against a discarded section. It should
811 this_inf->removed = 1;
815 && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
816 && cie->make_relative == 0)
817 || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
819 /* If a shared library uses absolute pointers
820 which we cannot turn into PC relative,
821 don't create the binary search table,
822 since it is affected by runtime relocations. */
823 hdr_info->table = FALSE;
824 (*info->callbacks->einfo)
825 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
826 " table being created.\n"), abfd, sec);
829 hdr_info->fde_count++;
830 this_inf->u.fde.cie_inf = (void *) (ecie - ecies);
833 /* Skip the initial location and address range. */
835 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
836 REQUIRE (skip_bytes (&buf, end, 2 * length));
838 /* Skip the augmentation size, if present. */
839 if (cie->augmentation[0] == 'z')
840 REQUIRE (read_uleb128 (&buf, end, &length));
844 /* Of the supported augmentation characters above, only 'L'
845 adds augmentation data to the FDE. This code would need to
846 be adjusted if any future augmentations do the same thing. */
847 if (cie->lsda_encoding != DW_EH_PE_omit)
849 this_inf->lsda_offset = buf - start;
850 /* If there's no 'z' augmentation, we don't know where the
851 CFA insns begin. Assume no padding. */
852 if (cie->augmentation[0] != 'z')
856 /* Skip over the augmentation data. */
857 REQUIRE (skip_bytes (&buf, end, length));
860 buf = last_fde + 4 + hdr_length;
864 /* Try to interpret the CFA instructions and find the first
865 padding nop. Shrink this_inf's size so that it doesn't
866 include the padding. */
867 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
869 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
870 /* If we don't understand the CFA instructions, we can't know
871 what needs to be adjusted there. */
872 if (insns_end == NULL
873 /* For the time being we don't support DW_CFA_set_loc in
875 || (set_loc_count && this_inf->cie))
877 this_inf->size -= end - insns_end;
878 if (insns_end != end && this_inf->cie)
880 cie->initial_insn_length -= end - insns_end;
881 cie->length -= end - insns_end;
884 && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
885 || cie->make_relative))
890 this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
891 * sizeof (unsigned int));
892 REQUIRE (this_inf->set_loc);
893 this_inf->set_loc[0] = set_loc_count;
898 if (*p == DW_CFA_set_loc)
899 this_inf->set_loc[++cnt] = p + 1 - start;
900 REQUIRE (skip_cfa_op (&p, end, length));
904 this_inf->fde_encoding = cie->fde_encoding;
905 this_inf->lsda_encoding = cie->lsda_encoding;
909 elf_section_data (sec)->sec_info = sec_info;
910 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
912 /* Look at all CIEs in this section and determine which can be
913 removed as unused, which can be merged with previous duplicate
914 CIEs and which need to be kept. */
915 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
917 if (ecie->usage_count == 0)
919 sec_info->entry[ecie->entry].removed = 1;
922 ecie->cie.output_sec = sec->output_section;
923 ecie->cie.cie_inf = sec_info->entry + ecie->entry;
924 cie_compute_hash (&ecie->cie);
925 if (hdr_info->cies != NULL)
927 void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
928 ecie->cie.hash, INSERT);
931 if (*loc != HTAB_EMPTY_ENTRY)
933 sec_info->entry[ecie->entry].removed = 1;
934 ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
938 *loc = malloc (sizeof (struct cie));
940 *loc = HTAB_DELETED_ENTRY;
942 memcpy (*loc, &ecie->cie, sizeof (struct cie));
945 ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
946 ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
947 ecie->cie.cie_inf->per_encoding_relative
948 = (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
951 /* Ok, now we can assign new offsets. */
953 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
958 ecie = ecies + (bfd_hostptr_t) ent->u.fde.cie_inf;
959 ent->u.fde.cie_inf = ecie->cie.cie_inf;
961 ent->new_offset = offset;
962 offset += size_of_output_cie_fde (ent, ptr_size);
965 /* Resize the sec as needed. */
966 sec->rawsize = sec->size;
972 return offset != sec->rawsize;
975 (*info->callbacks->einfo)
976 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
984 hdr_info->table = FALSE;
990 /* This function is called for .eh_frame_hdr section after
991 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
992 input sections. It finalizes the size of .eh_frame_hdr section. */
995 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
997 struct elf_link_hash_table *htab;
998 struct eh_frame_hdr_info *hdr_info;
1001 htab = elf_hash_table (info);
1002 hdr_info = &htab->eh_info;
1004 if (hdr_info->cies != NULL)
1006 htab_delete (hdr_info->cies);
1007 hdr_info->cies = NULL;
1010 sec = hdr_info->hdr_sec;
1014 sec->size = EH_FRAME_HDR_SIZE;
1015 if (hdr_info->table)
1016 sec->size += 4 + hdr_info->fde_count * 8;
1018 elf_tdata (abfd)->eh_frame_hdr = sec;
1022 /* This function is called from size_dynamic_sections.
1023 It needs to decide whether .eh_frame_hdr should be output or not,
1024 because when the dynamic symbol table has been sized it is too late
1025 to strip sections. */
1028 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1032 struct elf_link_hash_table *htab;
1033 struct eh_frame_hdr_info *hdr_info;
1035 htab = elf_hash_table (info);
1036 hdr_info = &htab->eh_info;
1037 if (hdr_info->hdr_sec == NULL)
1040 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1042 hdr_info->hdr_sec = NULL;
1047 if (info->eh_frame_hdr)
1048 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1050 /* Count only sections which have at least a single CIE or FDE.
1051 There cannot be any CIE or FDE <= 8 bytes. */
1052 o = bfd_get_section_by_name (abfd, ".eh_frame");
1053 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1059 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1060 hdr_info->hdr_sec = NULL;
1064 hdr_info->table = TRUE;
1068 /* Adjust an address in the .eh_frame section. Given OFFSET within
1069 SEC, this returns the new offset in the adjusted .eh_frame section,
1070 or -1 if the address refers to a CIE/FDE which has been removed
1071 or to offset with dynamic relocation which is no longer needed. */
1074 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1075 struct bfd_link_info *info,
1079 struct eh_frame_sec_info *sec_info;
1080 struct elf_link_hash_table *htab;
1081 struct eh_frame_hdr_info *hdr_info;
1082 unsigned int lo, hi, mid;
1084 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1086 sec_info = elf_section_data (sec)->sec_info;
1088 if (offset >= sec->rawsize)
1089 return offset - sec->rawsize + sec->size;
1091 htab = elf_hash_table (info);
1092 hdr_info = &htab->eh_info;
1093 if (hdr_info->offsets_adjusted)
1094 offset += sec->output_offset;
1097 hi = sec_info->count;
1101 mid = (lo + hi) / 2;
1102 if (offset < sec_info->entry[mid].offset)
1105 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1111 BFD_ASSERT (lo < hi);
1113 /* FDE or CIE was removed. */
1114 if (sec_info->entry[mid].removed)
1115 return (bfd_vma) -1;
1117 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1118 relocation against FDE's initial_location field. */
1119 if (!sec_info->entry[mid].cie
1120 && sec_info->entry[mid].u.fde.cie_inf->make_relative
1121 && offset == sec_info->entry[mid].offset + 8)
1122 return (bfd_vma) -2;
1124 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1125 for run-time relocation against LSDA field. */
1126 if (!sec_info->entry[mid].cie
1127 && sec_info->entry[mid].u.fde.cie_inf->make_lsda_relative
1128 && (offset == (sec_info->entry[mid].offset + 8
1129 + sec_info->entry[mid].lsda_offset))
1130 && (sec_info->entry[mid].u.fde.cie_inf->need_lsda_relative
1131 || !hdr_info->offsets_adjusted))
1133 sec_info->entry[mid].u.fde.cie_inf->need_lsda_relative = 1;
1134 return (bfd_vma) -2;
1137 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1138 relocation against DW_CFA_set_loc's arguments. */
1139 if (sec_info->entry[mid].set_loc
1140 && (sec_info->entry[mid].cie
1141 ? sec_info->entry[mid].make_relative
1142 : sec_info->entry[mid].u.fde.cie_inf->make_relative)
1143 && (offset >= sec_info->entry[mid].offset + 8
1144 + sec_info->entry[mid].set_loc[1]))
1148 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1149 if (offset == sec_info->entry[mid].offset + 8
1150 + sec_info->entry[mid].set_loc[cnt])
1151 return (bfd_vma) -2;
1154 if (hdr_info->offsets_adjusted)
1155 offset -= sec->output_offset;
1156 /* Any new augmentation bytes go before the first relocation. */
1157 return (offset + sec_info->entry[mid].new_offset
1158 - sec_info->entry[mid].offset
1159 + extra_augmentation_string_bytes (sec_info->entry + mid)
1160 + extra_augmentation_data_bytes (sec_info->entry + mid));
1163 /* Write out .eh_frame section. This is called with the relocated
1167 _bfd_elf_write_section_eh_frame (bfd *abfd,
1168 struct bfd_link_info *info,
1172 struct eh_frame_sec_info *sec_info;
1173 struct elf_link_hash_table *htab;
1174 struct eh_frame_hdr_info *hdr_info;
1175 unsigned int ptr_size;
1176 struct eh_cie_fde *ent;
1178 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1179 return bfd_set_section_contents (abfd, sec->output_section, contents,
1180 sec->output_offset, sec->size);
1182 ptr_size = (get_elf_backend_data (abfd)
1183 ->elf_backend_eh_frame_address_size (abfd, sec));
1184 BFD_ASSERT (ptr_size != 0);
1186 sec_info = elf_section_data (sec)->sec_info;
1187 htab = elf_hash_table (info);
1188 hdr_info = &htab->eh_info;
1190 /* First convert all offsets to output section offsets, so that a
1191 CIE offset is valid if the CIE is used by a FDE from some other
1192 section. This can happen when duplicate CIEs are deleted in
1193 _bfd_elf_discard_section_eh_frame. We do all sections here because
1194 this function might not be called on sections in the same order as
1195 _bfd_elf_discard_section_eh_frame. */
1196 if (!hdr_info->offsets_adjusted)
1200 struct eh_frame_sec_info *eh_inf;
1202 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1204 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1205 || (ibfd->flags & DYNAMIC) != 0)
1208 eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1209 if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1212 eh_inf = elf_section_data (eh)->sec_info;
1213 for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1215 ent->offset += eh->output_offset;
1216 ent->new_offset += eh->output_offset;
1219 hdr_info->offsets_adjusted = TRUE;
1222 if (hdr_info->table && hdr_info->array == NULL)
1224 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1225 if (hdr_info->array == NULL)
1228 /* The new offsets can be bigger or smaller than the original offsets.
1229 We therefore need to make two passes over the section: one backward
1230 pass to move entries up and one forward pass to move entries down.
1231 The two passes won't interfere with each other because entries are
1233 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1234 if (!ent->removed && ent->new_offset > ent->offset)
1235 memmove (contents + ent->new_offset - sec->output_offset,
1236 contents + ent->offset - sec->output_offset, ent->size);
1238 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1239 if (!ent->removed && ent->new_offset < ent->offset)
1240 memmove (contents + ent->new_offset - sec->output_offset,
1241 contents + ent->offset - sec->output_offset, ent->size);
1243 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1245 unsigned char *buf, *end;
1246 unsigned int new_size;
1253 /* Any terminating FDE must be at the end of the section. */
1254 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1258 buf = contents + ent->new_offset - sec->output_offset;
1259 end = buf + ent->size;
1260 new_size = size_of_output_cie_fde (ent, ptr_size);
1262 /* Update the size. It may be shrinked. */
1263 bfd_put_32 (abfd, new_size - 4, buf);
1265 /* Filling the extra bytes with DW_CFA_nops. */
1266 if (new_size != ent->size)
1267 memset (end, 0, new_size - ent->size);
1272 if (ent->make_relative
1273 || ent->need_lsda_relative
1274 || ent->per_encoding_relative)
1277 unsigned int action, extra_string, extra_data;
1278 unsigned int per_width, per_encoding;
1280 /* Need to find 'R' or 'L' augmentation's argument and modify
1281 DW_EH_PE_* value. */
1282 action = ((ent->make_relative ? 1 : 0)
1283 | (ent->need_lsda_relative ? 2 : 0)
1284 | (ent->per_encoding_relative ? 4 : 0));
1285 extra_string = extra_augmentation_string_bytes (ent);
1286 extra_data = extra_augmentation_data_bytes (ent);
1288 /* Skip length, id and version. */
1291 buf += strlen (aug) + 1;
1292 skip_leb128 (&buf, end);
1293 skip_leb128 (&buf, end);
1294 skip_leb128 (&buf, end);
1297 /* The uleb128 will always be a single byte for the kind
1298 of augmentation strings that we're prepared to handle. */
1299 *buf++ += extra_data;
1303 /* Make room for the new augmentation string and data bytes. */
1304 memmove (buf + extra_string + extra_data, buf, end - buf);
1305 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1306 buf += extra_string;
1307 end += extra_string + extra_data;
1309 if (ent->add_augmentation_size)
1312 *buf++ = extra_data - 1;
1314 if (ent->add_fde_encoding)
1316 BFD_ASSERT (action & 1);
1318 *buf++ = DW_EH_PE_pcrel;
1328 BFD_ASSERT (*buf == ent->lsda_encoding);
1329 *buf |= DW_EH_PE_pcrel;
1335 per_encoding = *buf++;
1336 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1337 BFD_ASSERT (per_width != 0);
1338 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1339 == ent->per_encoding_relative);
1340 if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1342 + ((buf - contents + per_width - 1)
1343 & ~((bfd_size_type) per_width - 1)));
1348 val = read_value (abfd, buf, per_width,
1349 get_DW_EH_PE_signed (per_encoding));
1350 val += ent->offset - ent->new_offset;
1351 val -= extra_string + extra_data;
1352 write_value (abfd, buf, val, per_width);
1360 BFD_ASSERT (*buf == ent->fde_encoding);
1361 *buf |= DW_EH_PE_pcrel;
1376 bfd_vma value, address;
1379 struct eh_cie_fde *cie;
1382 cie = ent->u.fde.cie_inf;
1384 value = ent->new_offset + 4 - cie->new_offset;
1385 bfd_put_32 (abfd, value, buf);
1387 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1388 value = read_value (abfd, buf, width,
1389 get_DW_EH_PE_signed (ent->fde_encoding));
1393 switch (ent->fde_encoding & 0xf0)
1395 case DW_EH_PE_indirect:
1396 case DW_EH_PE_textrel:
1397 BFD_ASSERT (hdr_info == NULL);
1399 case DW_EH_PE_datarel:
1401 asection *got = bfd_get_section_by_name (abfd, ".got");
1403 BFD_ASSERT (got != NULL);
1404 address += got->vma;
1407 case DW_EH_PE_pcrel:
1408 value += ent->offset - ent->new_offset;
1409 address += sec->output_section->vma + ent->offset + 8;
1412 if (cie->make_relative)
1413 value -= sec->output_section->vma + ent->new_offset + 8;
1414 write_value (abfd, buf, value, width);
1421 hdr_info->array[hdr_info->array_count].initial_loc = address;
1422 hdr_info->array[hdr_info->array_count++].fde
1423 = sec->output_section->vma + ent->new_offset;
1426 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1427 || cie->need_lsda_relative)
1429 buf += ent->lsda_offset;
1430 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1431 value = read_value (abfd, buf, width,
1432 get_DW_EH_PE_signed (ent->lsda_encoding));
1435 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1436 value += ent->offset - ent->new_offset;
1437 else if (cie->need_lsda_relative)
1438 value -= (sec->output_section->vma + ent->new_offset + 8
1439 + ent->lsda_offset);
1440 write_value (abfd, buf, value, width);
1443 else if (cie->add_augmentation_size)
1445 /* Skip the PC and length and insert a zero byte for the
1446 augmentation size. */
1448 memmove (buf + 1, buf, end - buf);
1454 /* Adjust DW_CFA_set_loc. */
1455 unsigned int cnt, width;
1458 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1459 new_offset = ent->new_offset + 8
1460 + extra_augmentation_string_bytes (ent)
1461 + extra_augmentation_data_bytes (ent);
1463 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1466 buf = start + ent->set_loc[cnt];
1468 value = read_value (abfd, buf, width,
1469 get_DW_EH_PE_signed (ent->fde_encoding));
1473 if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1474 value += ent->offset + 8 - new_offset;
1475 if (cie->make_relative)
1476 value -= sec->output_section->vma + new_offset
1477 + ent->set_loc[cnt];
1478 write_value (abfd, buf, value, width);
1484 /* We don't align the section to its section alignment since the
1485 runtime library only expects all CIE/FDE records aligned at
1486 the pointer size. _bfd_elf_discard_section_eh_frame should
1487 have padded CIE/FDE records to multiple of pointer size with
1488 size_of_output_cie_fde. */
1489 if ((sec->size % ptr_size) != 0)
1492 return bfd_set_section_contents (abfd, sec->output_section,
1493 contents, (file_ptr) sec->output_offset,
1497 /* Helper function used to sort .eh_frame_hdr search table by increasing
1498 VMA of FDE initial location. */
1501 vma_compare (const void *a, const void *b)
1503 const struct eh_frame_array_ent *p = a;
1504 const struct eh_frame_array_ent *q = b;
1505 if (p->initial_loc > q->initial_loc)
1507 if (p->initial_loc < q->initial_loc)
1512 /* Write out .eh_frame_hdr section. This must be called after
1513 _bfd_elf_write_section_eh_frame has been called on all input
1515 .eh_frame_hdr format:
1516 ubyte version (currently 1)
1517 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1519 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1520 number (or DW_EH_PE_omit if there is no
1521 binary search table computed))
1522 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1523 or DW_EH_PE_omit if not present.
1524 DW_EH_PE_datarel is using address of
1525 .eh_frame_hdr section start as base)
1526 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1527 optionally followed by:
1528 [encoded] fde_count (total number of FDEs in .eh_frame section)
1529 fde_count x [encoded] initial_loc, fde
1530 (array of encoded pairs containing
1531 FDE initial_location field and FDE address,
1532 sorted by increasing initial_loc). */
1535 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1537 struct elf_link_hash_table *htab;
1538 struct eh_frame_hdr_info *hdr_info;
1541 asection *eh_frame_sec;
1544 bfd_vma encoded_eh_frame;
1546 htab = elf_hash_table (info);
1547 hdr_info = &htab->eh_info;
1548 sec = hdr_info->hdr_sec;
1552 size = EH_FRAME_HDR_SIZE;
1553 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1554 size += 4 + hdr_info->fde_count * 8;
1555 contents = bfd_malloc (size);
1556 if (contents == NULL)
1559 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1560 if (eh_frame_sec == NULL)
1566 memset (contents, 0, EH_FRAME_HDR_SIZE);
1567 contents[0] = 1; /* Version. */
1568 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1569 (abfd, info, eh_frame_sec, 0, sec, 4,
1570 &encoded_eh_frame); /* .eh_frame offset. */
1572 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1574 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1575 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1579 contents[2] = DW_EH_PE_omit;
1580 contents[3] = DW_EH_PE_omit;
1582 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1584 if (contents[2] != DW_EH_PE_omit)
1588 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1589 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1591 for (i = 0; i < hdr_info->fde_count; i++)
1594 hdr_info->array[i].initial_loc
1595 - sec->output_section->vma,
1596 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1598 hdr_info->array[i].fde - sec->output_section->vma,
1599 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1603 retval = bfd_set_section_contents (abfd, sec->output_section,
1604 contents, (file_ptr) sec->output_offset,
1610 /* Return the width of FDE addresses. This is the default implementation. */
1613 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1615 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1618 /* Decide whether we can use a PC-relative encoding within the given
1619 EH frame section. This is the default implementation. */
1622 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1623 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1624 asection *eh_frame_section ATTRIBUTE_UNUSED)
1629 /* Select an encoding for the given address. Preference is given to
1630 PC-relative addressing modes. */
1633 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1634 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1635 asection *osec, bfd_vma offset,
1636 asection *loc_sec, bfd_vma loc_offset,
1639 *encoded = osec->vma + offset -
1640 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1641 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;