daily update
[binutils.git] / bfd / elf-eh-frame.c
blob8380ef86004e9b0dd26b21688ac2e7bda36724ed
1 /* .eh_frame section optimization.
2 Copyright 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
4 Written by Jakub Jelinek <jakub@redhat.com>.
6 This file is part of BFD, the Binary File Descriptor library.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
23 #include "sysdep.h"
24 #include "bfd.h"
25 #include "libbfd.h"
26 #include "elf-bfd.h"
27 #include "dwarf2.h"
29 #define EH_FRAME_HDR_SIZE 8
31 struct cie
33 unsigned int length;
34 unsigned int hash;
35 unsigned char version;
36 unsigned char local_personality;
37 char augmentation[20];
38 bfd_vma code_align;
39 bfd_signed_vma data_align;
40 bfd_vma ra_column;
41 bfd_vma augmentation_size;
42 union {
43 struct elf_link_hash_entry *h;
44 bfd_vma val;
45 unsigned int reloc_index;
46 } personality;
47 asection *output_sec;
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)
65 if (*iter >= end)
66 return FALSE;
67 *result = *((*iter)++);
68 return TRUE;
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)
79 *iter = end;
80 return FALSE;
82 *iter += length;
83 return TRUE;
86 /* Move *ITER over an leb128, stopping at END. Return true if the end
87 of the leb128 was found. */
89 static bfd_boolean
90 skip_leb128 (bfd_byte **iter, bfd_byte *end)
92 unsigned char byte;
94 if (!read_byte (iter, end, &byte))
95 return FALSE;
96 while (byte & 0x80);
97 return TRUE;
100 /* Like skip_leb128, but treat the leb128 as an unsigned value and
101 store it in *VALUE. */
103 static bfd_boolean
104 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
106 bfd_byte *start, *p;
108 start = *iter;
109 if (!skip_leb128 (iter, end))
110 return FALSE;
112 p = *iter;
113 *value = *--p;
114 while (p > start)
115 *value = (*value << 7) | (*--p & 0x7f);
117 return TRUE;
120 /* Like read_uleb128, but for signed values. */
122 static bfd_boolean
123 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
125 bfd_byte *start, *p;
127 start = *iter;
128 if (!skip_leb128 (iter, end))
129 return FALSE;
131 p = *iter;
132 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
133 while (p > start)
134 *value = (*value << 7) | (*--p & 0x7f);
136 return TRUE;
139 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
141 static
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
145 was added to bfd. */
146 if ((encoding & 0x60) == 0x60)
147 return 0;
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;
155 default:
156 break;
159 return 0;
162 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164 /* Read a width sized value from memory. */
166 static bfd_vma
167 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
169 bfd_vma value;
171 switch (width)
173 case 2:
174 if (is_signed)
175 value = bfd_get_signed_16 (abfd, buf);
176 else
177 value = bfd_get_16 (abfd, buf);
178 break;
179 case 4:
180 if (is_signed)
181 value = bfd_get_signed_32 (abfd, buf);
182 else
183 value = bfd_get_32 (abfd, buf);
184 break;
185 case 8:
186 if (is_signed)
187 value = bfd_get_signed_64 (abfd, buf);
188 else
189 value = bfd_get_64 (abfd, buf);
190 break;
191 default:
192 BFD_FAIL ();
193 return 0;
196 return value;
199 /* Store a width sized value to memory. */
201 static void
202 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
204 switch (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. */
215 static int
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)
241 return 1;
243 return 0;
246 static hashval_t
247 cie_hash (const void *e)
249 const struct cie *c = (const struct cie *) e;
250 return c->hash;
253 static hashval_t
254 cie_compute_hash (struct cie *c)
256 hashval_t h = 0;
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);
271 c->hash = h;
272 return 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;
282 if (entry->cie)
284 if (entry->add_augmentation_size)
285 size++;
286 if (entry->u.cie.add_fde_encoding)
287 size++;
289 return size;
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)
299 size++;
300 if (entry->cie && entry->u.cie.add_fde_encoding)
301 size++;
302 return size;
305 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
306 required alignment of ENTRY in bytes. */
308 static unsigned int
309 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
311 if (entry->removed)
312 return 0;
313 if (entry->size == 4)
314 return 4;
315 return (entry->size
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. */
325 static bfd_boolean
326 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
328 bfd_byte op;
329 bfd_vma length;
331 if (!read_byte (iter, end, &op))
332 return FALSE;
334 switch (op & 0xc0 ? op & 0xc0 : op)
336 case DW_CFA_nop:
337 case DW_CFA_advance_loc:
338 case DW_CFA_restore:
339 case DW_CFA_remember_state:
340 case DW_CFA_restore_state:
341 case DW_CFA_GNU_window_save:
342 /* No arguments. */
343 return TRUE;
345 case DW_CFA_offset:
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:
360 case DW_CFA_def_cfa:
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));
380 case DW_CFA_set_loc:
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);
395 default:
396 return FALSE;
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. */
405 static bfd_byte *
406 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
407 unsigned int *set_loc_count)
409 bfd_byte *last;
411 last = buf;
412 while (buf < end)
413 if (*buf == DW_CFA_nop)
414 buf++;
415 else
417 if (*buf == DW_CFA_set_loc)
418 ++*set_loc_count;
419 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
420 return 0;
421 last = buf;
423 return last;
426 /* Convert absolute encoding ENCODING into PC-relative form.
427 SIZE is the size of a pointer. */
429 static unsigned char
430 make_pc_relative (unsigned char encoding, unsigned int ptr_size)
432 if ((encoding & 0x7f) == DW_EH_PE_absptr)
433 switch (ptr_size)
435 case 2:
436 encoding |= DW_EH_PE_sdata2;
437 break;
438 case 4:
439 encoding |= DW_EH_PE_sdata4;
440 break;
441 case 8:
442 encoding |= DW_EH_PE_sdata8;
443 break;
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. */
451 void
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. */
464 void
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) \
469 do \
470 if (!(COND)) \
471 goto free_no_table; \
472 while (0)
474 bfd_byte *ehbuf = NULL, *buf, *end;
475 bfd_byte *last_fde;
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)
491 return;
493 if (sec->size == 0)
495 /* This file does not contain .eh_frame information. */
496 return;
499 if (bfd_is_abs_section (sec->output_section))
501 /* At least one of the sections is being discarded from the
502 link, so we should just ignore them. */
503 return;
506 /* Read the frame unwind information from abfd. */
508 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
510 if (sec->size >= 4
511 && bfd_get_32 (abfd, ehbuf) == 0
512 && cookie->rel == cookie->relend)
514 /* Empty .eh_frame section. */
515 free (ehbuf);
516 return;
519 /* If .eh_frame section size doesn't fit into int, we cannot handle
520 it (it would need to use 64-bit .eh_frame format anyway). */
521 REQUIRE (sec->size == (unsigned int) sec->size);
523 ptr_size = (get_elf_backend_data (abfd)
524 ->elf_backend_eh_frame_address_size (abfd, sec));
525 REQUIRE (ptr_size != 0);
527 /* Go through the section contents and work out how many FDEs and
528 CIEs there are. */
529 buf = ehbuf;
530 end = ehbuf + sec->size;
531 num_cies = 0;
532 num_entries = 0;
533 while (buf != end)
535 num_entries++;
537 /* Read the length of the entry. */
538 REQUIRE (skip_bytes (&buf, end, 4));
539 hdr_length = bfd_get_32 (abfd, buf - 4);
541 /* 64-bit .eh_frame is not supported. */
542 REQUIRE (hdr_length != 0xffffffff);
543 if (hdr_length == 0)
544 break;
546 REQUIRE (skip_bytes (&buf, end, 4));
547 hdr_id = bfd_get_32 (abfd, buf - 4);
548 if (hdr_id == 0)
549 num_cies++;
551 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
554 sec_info = (struct eh_frame_sec_info *)
555 bfd_zmalloc (sizeof (struct eh_frame_sec_info)
556 + (num_entries - 1) * sizeof (struct eh_cie_fde));
557 REQUIRE (sec_info);
559 /* We need to have a "struct cie" for each CIE in this section. */
560 local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
561 REQUIRE (local_cies);
563 /* FIXME: octets_per_byte. */
564 #define ENSURE_NO_RELOCS(buf) \
565 REQUIRE (!(cookie->rel < cookie->relend \
566 && (cookie->rel->r_offset \
567 < (bfd_size_type) ((buf) - ehbuf)) \
568 && cookie->rel->r_info != 0))
570 /* FIXME: octets_per_byte. */
571 #define SKIP_RELOCS(buf) \
572 while (cookie->rel < cookie->relend \
573 && (cookie->rel->r_offset \
574 < (bfd_size_type) ((buf) - ehbuf))) \
575 cookie->rel++
577 /* FIXME: octets_per_byte. */
578 #define GET_RELOC(buf) \
579 ((cookie->rel < cookie->relend \
580 && (cookie->rel->r_offset \
581 == (bfd_size_type) ((buf) - ehbuf))) \
582 ? cookie->rel : NULL)
584 buf = ehbuf;
585 cie_count = 0;
586 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
587 while ((bfd_size_type) (buf - ehbuf) != sec->size)
589 char *aug;
590 bfd_byte *start, *insns, *insns_end;
591 bfd_size_type length;
592 unsigned int set_loc_count;
594 this_inf = sec_info->entry + sec_info->count;
595 last_fde = buf;
597 /* Read the length of the entry. */
598 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
599 hdr_length = bfd_get_32 (abfd, buf - 4);
601 /* The CIE/FDE must be fully contained in this input section. */
602 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
603 end = buf + hdr_length;
605 this_inf->offset = last_fde - ehbuf;
606 this_inf->size = 4 + hdr_length;
607 this_inf->reloc_index = cookie->rel - cookie->rels;
609 if (hdr_length == 0)
611 /* A zero-length CIE should only be found at the end of
612 the section. */
613 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
614 ENSURE_NO_RELOCS (buf);
615 sec_info->count++;
616 break;
619 REQUIRE (skip_bytes (&buf, end, 4));
620 hdr_id = bfd_get_32 (abfd, buf - 4);
622 if (hdr_id == 0)
624 unsigned int initial_insn_length;
626 /* CIE */
627 this_inf->cie = 1;
629 /* Point CIE to one of the section-local cie structures. */
630 cie = local_cies + cie_count++;
632 cie->cie_inf = this_inf;
633 cie->length = hdr_length;
634 cie->output_sec = sec->output_section;
635 start = buf;
636 REQUIRE (read_byte (&buf, end, &cie->version));
638 /* Cannot handle unknown versions. */
639 REQUIRE (cie->version == 1
640 || cie->version == 3
641 || cie->version == 4);
642 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
644 strcpy (cie->augmentation, (char *) buf);
645 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
646 ENSURE_NO_RELOCS (buf);
647 if (buf[0] == 'e' && buf[1] == 'h')
649 /* GCC < 3.0 .eh_frame CIE */
650 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
651 is private to each CIE, so we don't need it for anything.
652 Just skip it. */
653 REQUIRE (skip_bytes (&buf, end, ptr_size));
654 SKIP_RELOCS (buf);
656 if (cie->version >= 4)
658 REQUIRE (buf + 1 < end);
659 REQUIRE (buf[0] == ptr_size);
660 REQUIRE (buf[1] == 0);
661 buf += 2;
663 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
664 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
665 if (cie->version == 1)
667 REQUIRE (buf < end);
668 cie->ra_column = *buf++;
670 else
671 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
672 ENSURE_NO_RELOCS (buf);
673 cie->lsda_encoding = DW_EH_PE_omit;
674 cie->fde_encoding = DW_EH_PE_omit;
675 cie->per_encoding = DW_EH_PE_omit;
676 aug = cie->augmentation;
677 if (aug[0] != 'e' || aug[1] != 'h')
679 if (*aug == 'z')
681 aug++;
682 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
683 ENSURE_NO_RELOCS (buf);
686 while (*aug != '\0')
687 switch (*aug++)
689 case 'L':
690 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
691 ENSURE_NO_RELOCS (buf);
692 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
693 break;
694 case 'R':
695 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
696 ENSURE_NO_RELOCS (buf);
697 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
698 break;
699 case 'S':
700 break;
701 case 'P':
703 int per_width;
705 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
706 per_width = get_DW_EH_PE_width (cie->per_encoding,
707 ptr_size);
708 REQUIRE (per_width);
709 if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
711 length = -(buf - ehbuf) & (per_width - 1);
712 REQUIRE (skip_bytes (&buf, end, length));
714 this_inf->u.cie.personality_offset = buf - start;
715 ENSURE_NO_RELOCS (buf);
716 /* Ensure we have a reloc here. */
717 REQUIRE (GET_RELOC (buf));
718 cie->personality.reloc_index
719 = cookie->rel - cookie->rels;
720 /* Cope with MIPS-style composite relocations. */
722 cookie->rel++;
723 while (GET_RELOC (buf) != NULL);
724 REQUIRE (skip_bytes (&buf, end, per_width));
726 break;
727 default:
728 /* Unrecognized augmentation. Better bail out. */
729 goto free_no_table;
733 /* For shared libraries, try to get rid of as many RELATIVE relocs
734 as possible. */
735 if (info->shared
736 && (get_elf_backend_data (abfd)
737 ->elf_backend_can_make_relative_eh_frame
738 (abfd, info, sec)))
740 if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
741 this_inf->make_relative = 1;
742 /* If the CIE doesn't already have an 'R' entry, it's fairly
743 easy to add one, provided that there's no aligned data
744 after the augmentation string. */
745 else if (cie->fde_encoding == DW_EH_PE_omit
746 && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
748 if (*cie->augmentation == 0)
749 this_inf->add_augmentation_size = 1;
750 this_inf->u.cie.add_fde_encoding = 1;
751 this_inf->make_relative = 1;
754 if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
755 cie->can_make_lsda_relative = 1;
758 /* If FDE encoding was not specified, it defaults to
759 DW_EH_absptr. */
760 if (cie->fde_encoding == DW_EH_PE_omit)
761 cie->fde_encoding = DW_EH_PE_absptr;
763 initial_insn_length = end - buf;
764 if (initial_insn_length <= sizeof (cie->initial_instructions))
766 cie->initial_insn_length = initial_insn_length;
767 memcpy (cie->initial_instructions, buf, initial_insn_length);
769 insns = buf;
770 buf += initial_insn_length;
771 ENSURE_NO_RELOCS (buf);
773 if (hdr_info->merge_cies)
774 this_inf->u.cie.u.full_cie = cie;
775 this_inf->u.cie.per_encoding_relative
776 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
778 else
780 asection *rsec;
782 /* Find the corresponding CIE. */
783 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
784 for (cie = local_cies; cie < local_cies + cie_count; cie++)
785 if (cie_offset == cie->cie_inf->offset)
786 break;
788 /* Ensure this FDE references one of the CIEs in this input
789 section. */
790 REQUIRE (cie != local_cies + cie_count);
791 this_inf->u.fde.cie_inf = cie->cie_inf;
792 this_inf->make_relative = cie->cie_inf->make_relative;
793 this_inf->add_augmentation_size
794 = cie->cie_inf->add_augmentation_size;
796 ENSURE_NO_RELOCS (buf);
797 REQUIRE (GET_RELOC (buf));
799 /* Chain together the FDEs for each section. */
800 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
801 /* RSEC will be NULL if FDE was cleared out as it was belonging to
802 a discarded SHT_GROUP. */
803 if (rsec)
805 REQUIRE (rsec->owner == abfd);
806 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
807 elf_fde_list (rsec) = this_inf;
810 /* Skip the initial location and address range. */
811 start = buf;
812 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
813 REQUIRE (skip_bytes (&buf, end, 2 * length));
815 /* Skip the augmentation size, if present. */
816 if (cie->augmentation[0] == 'z')
817 REQUIRE (read_uleb128 (&buf, end, &length));
818 else
819 length = 0;
821 /* Of the supported augmentation characters above, only 'L'
822 adds augmentation data to the FDE. This code would need to
823 be adjusted if any future augmentations do the same thing. */
824 if (cie->lsda_encoding != DW_EH_PE_omit)
826 SKIP_RELOCS (buf);
827 if (cie->can_make_lsda_relative && GET_RELOC (buf))
828 cie->cie_inf->u.cie.make_lsda_relative = 1;
829 this_inf->lsda_offset = buf - start;
830 /* If there's no 'z' augmentation, we don't know where the
831 CFA insns begin. Assume no padding. */
832 if (cie->augmentation[0] != 'z')
833 length = end - buf;
836 /* Skip over the augmentation data. */
837 REQUIRE (skip_bytes (&buf, end, length));
838 insns = buf;
840 buf = last_fde + 4 + hdr_length;
842 /* For NULL RSEC (cleared FDE belonging to a discarded section)
843 the relocations are commonly cleared. We do not sanity check if
844 all these relocations are cleared as (1) relocations to
845 .gcc_except_table will remain uncleared (they will get dropped
846 with the drop of this unused FDE) and (2) BFD already safely drops
847 relocations of any type to .eh_frame by
848 elf_section_ignore_discarded_relocs.
849 TODO: The .gcc_except_table entries should be also filtered as
850 .eh_frame entries; or GCC could rather use COMDAT for them. */
851 SKIP_RELOCS (buf);
854 /* Try to interpret the CFA instructions and find the first
855 padding nop. Shrink this_inf's size so that it doesn't
856 include the padding. */
857 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
858 set_loc_count = 0;
859 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
860 /* If we don't understand the CFA instructions, we can't know
861 what needs to be adjusted there. */
862 if (insns_end == NULL
863 /* For the time being we don't support DW_CFA_set_loc in
864 CIE instructions. */
865 || (set_loc_count && this_inf->cie))
866 goto free_no_table;
867 this_inf->size -= end - insns_end;
868 if (insns_end != end && this_inf->cie)
870 cie->initial_insn_length -= end - insns_end;
871 cie->length -= end - insns_end;
873 if (set_loc_count
874 && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
875 || this_inf->make_relative))
877 unsigned int cnt;
878 bfd_byte *p;
880 this_inf->set_loc = (unsigned int *)
881 bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
882 REQUIRE (this_inf->set_loc);
883 this_inf->set_loc[0] = set_loc_count;
884 p = insns;
885 cnt = 0;
886 while (p < end)
888 if (*p == DW_CFA_set_loc)
889 this_inf->set_loc[++cnt] = p + 1 - start;
890 REQUIRE (skip_cfa_op (&p, end, length));
894 this_inf->removed = 1;
895 this_inf->fde_encoding = cie->fde_encoding;
896 this_inf->lsda_encoding = cie->lsda_encoding;
897 sec_info->count++;
899 BFD_ASSERT (sec_info->count == num_entries);
900 BFD_ASSERT (cie_count == num_cies);
902 elf_section_data (sec)->sec_info = sec_info;
903 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
904 if (hdr_info->merge_cies)
906 sec_info->cies = local_cies;
907 local_cies = NULL;
909 goto success;
911 free_no_table:
912 (*info->callbacks->einfo)
913 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
914 abfd, sec);
915 hdr_info->table = FALSE;
916 if (sec_info)
917 free (sec_info);
918 success:
919 if (ehbuf)
920 free (ehbuf);
921 if (local_cies)
922 free (local_cies);
923 #undef REQUIRE
926 /* Finish a pass over all .eh_frame sections. */
928 void
929 _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
931 struct eh_frame_hdr_info *hdr_info;
933 hdr_info = &elf_hash_table (info)->eh_info;
934 hdr_info->parsed_eh_frames = TRUE;
937 /* Mark all relocations against CIE or FDE ENT, which occurs in
938 .eh_frame section SEC. COOKIE describes the relocations in SEC;
939 its "rel" field can be changed freely. */
941 static bfd_boolean
942 mark_entry (struct bfd_link_info *info, asection *sec,
943 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
944 struct elf_reloc_cookie *cookie)
946 /* FIXME: octets_per_byte. */
947 for (cookie->rel = cookie->rels + ent->reloc_index;
948 cookie->rel < cookie->relend
949 && cookie->rel->r_offset < ent->offset + ent->size;
950 cookie->rel++)
951 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
952 return FALSE;
954 return TRUE;
957 /* Mark all the relocations against FDEs that relate to code in input
958 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
959 relocations are described by COOKIE. */
961 bfd_boolean
962 _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
963 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
964 struct elf_reloc_cookie *cookie)
966 struct eh_cie_fde *fde, *cie;
968 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
970 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
971 return FALSE;
973 /* At this stage, all cie_inf fields point to local CIEs, so we
974 can use the same cookie to refer to them. */
975 cie = fde->u.fde.cie_inf;
976 if (!cie->u.cie.gc_mark)
978 cie->u.cie.gc_mark = 1;
979 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
980 return FALSE;
983 return TRUE;
986 /* Input section SEC of ABFD is an .eh_frame section that contains the
987 CIE described by CIE_INF. Return a version of CIE_INF that is going
988 to be kept in the output, adding CIE_INF to the output if necessary.
990 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
991 relocations in REL. */
993 static struct eh_cie_fde *
994 find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
995 struct eh_frame_hdr_info *hdr_info,
996 struct elf_reloc_cookie *cookie,
997 struct eh_cie_fde *cie_inf)
999 unsigned long r_symndx;
1000 struct cie *cie, *new_cie;
1001 Elf_Internal_Rela *rel;
1002 void **loc;
1004 /* Use CIE_INF if we have already decided to keep it. */
1005 if (!cie_inf->removed)
1006 return cie_inf;
1008 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1009 if (cie_inf->u.cie.merged)
1010 return cie_inf->u.cie.u.merged_with;
1012 cie = cie_inf->u.cie.u.full_cie;
1014 /* Assume we will need to keep CIE_INF. */
1015 cie_inf->removed = 0;
1016 cie_inf->u.cie.u.sec = sec;
1018 /* If we are not merging CIEs, use CIE_INF. */
1019 if (cie == NULL)
1020 return cie_inf;
1022 if (cie->per_encoding != DW_EH_PE_omit)
1024 bfd_boolean per_binds_local;
1026 /* Work out the address of personality routine, either as an absolute
1027 value or as a symbol. */
1028 rel = cookie->rels + cie->personality.reloc_index;
1029 memset (&cie->personality, 0, sizeof (cie->personality));
1030 #ifdef BFD64
1031 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1032 r_symndx = ELF64_R_SYM (rel->r_info);
1033 else
1034 #endif
1035 r_symndx = ELF32_R_SYM (rel->r_info);
1036 if (r_symndx >= cookie->locsymcount
1037 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1039 struct elf_link_hash_entry *h;
1041 r_symndx -= cookie->extsymoff;
1042 h = cookie->sym_hashes[r_symndx];
1044 while (h->root.type == bfd_link_hash_indirect
1045 || h->root.type == bfd_link_hash_warning)
1046 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1048 cie->personality.h = h;
1049 per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1051 else
1053 Elf_Internal_Sym *sym;
1054 asection *sym_sec;
1056 sym = &cookie->locsyms[r_symndx];
1057 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1058 if (sym_sec == NULL)
1059 return cie_inf;
1061 if (sym_sec->kept_section != NULL)
1062 sym_sec = sym_sec->kept_section;
1063 if (sym_sec->output_section == NULL)
1064 return cie_inf;
1066 cie->local_personality = 1;
1067 cie->personality.val = (sym->st_value
1068 + sym_sec->output_offset
1069 + sym_sec->output_section->vma);
1070 per_binds_local = TRUE;
1073 if (per_binds_local
1074 && info->shared
1075 && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1076 && (get_elf_backend_data (abfd)
1077 ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1079 cie_inf->u.cie.make_per_encoding_relative = 1;
1080 cie_inf->u.cie.per_encoding_relative = 1;
1084 /* See if we can merge this CIE with an earlier one. */
1085 cie->output_sec = sec->output_section;
1086 cie_compute_hash (cie);
1087 if (hdr_info->cies == NULL)
1089 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1090 if (hdr_info->cies == NULL)
1091 return cie_inf;
1093 loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1094 if (loc == NULL)
1095 return cie_inf;
1097 new_cie = (struct cie *) *loc;
1098 if (new_cie == NULL)
1100 /* Keep CIE_INF and record it in the hash table. */
1101 new_cie = (struct cie *) malloc (sizeof (struct cie));
1102 if (new_cie == NULL)
1103 return cie_inf;
1105 memcpy (new_cie, cie, sizeof (struct cie));
1106 *loc = new_cie;
1108 else
1110 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1111 cie_inf->removed = 1;
1112 cie_inf->u.cie.merged = 1;
1113 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1114 if (cie_inf->u.cie.make_lsda_relative)
1115 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1117 return new_cie->cie_inf;
1120 /* This function is called for each input file before the .eh_frame
1121 section is relocated. It discards duplicate CIEs and FDEs for discarded
1122 functions. The function returns TRUE iff any entries have been
1123 deleted. */
1125 bfd_boolean
1126 _bfd_elf_discard_section_eh_frame
1127 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1128 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1129 struct elf_reloc_cookie *cookie)
1131 struct eh_cie_fde *ent;
1132 struct eh_frame_sec_info *sec_info;
1133 struct eh_frame_hdr_info *hdr_info;
1134 unsigned int ptr_size, offset;
1136 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1137 if (sec_info == NULL)
1138 return FALSE;
1140 hdr_info = &elf_hash_table (info)->eh_info;
1141 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1142 if (ent->size == 4)
1143 /* There should only be one zero terminator, on the last input
1144 file supplying .eh_frame (crtend.o). Remove any others. */
1145 ent->removed = sec->map_head.s != NULL;
1146 else if (!ent->cie)
1148 cookie->rel = cookie->rels + ent->reloc_index;
1149 /* FIXME: octets_per_byte. */
1150 BFD_ASSERT (cookie->rel < cookie->relend
1151 && cookie->rel->r_offset == ent->offset + 8);
1152 if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1154 if (info->shared
1155 && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1156 && ent->make_relative == 0)
1157 || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1159 /* If a shared library uses absolute pointers
1160 which we cannot turn into PC relative,
1161 don't create the binary search table,
1162 since it is affected by runtime relocations. */
1163 hdr_info->table = FALSE;
1164 (*info->callbacks->einfo)
1165 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1166 " table being created.\n"), abfd, sec);
1168 ent->removed = 0;
1169 hdr_info->fde_count++;
1170 ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1171 cookie, ent->u.fde.cie_inf);
1175 if (sec_info->cies)
1177 free (sec_info->cies);
1178 sec_info->cies = NULL;
1181 ptr_size = (get_elf_backend_data (sec->owner)
1182 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1183 offset = 0;
1184 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1185 if (!ent->removed)
1187 ent->new_offset = offset;
1188 offset += size_of_output_cie_fde (ent, ptr_size);
1191 sec->rawsize = sec->size;
1192 sec->size = offset;
1193 return offset != sec->rawsize;
1196 /* This function is called for .eh_frame_hdr section after
1197 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1198 input sections. It finalizes the size of .eh_frame_hdr section. */
1200 bfd_boolean
1201 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1203 struct elf_link_hash_table *htab;
1204 struct eh_frame_hdr_info *hdr_info;
1205 asection *sec;
1207 htab = elf_hash_table (info);
1208 hdr_info = &htab->eh_info;
1210 if (hdr_info->cies != NULL)
1212 htab_delete (hdr_info->cies);
1213 hdr_info->cies = NULL;
1216 sec = hdr_info->hdr_sec;
1217 if (sec == NULL)
1218 return FALSE;
1220 sec->size = EH_FRAME_HDR_SIZE;
1221 if (hdr_info->table)
1222 sec->size += 4 + hdr_info->fde_count * 8;
1224 elf_tdata (abfd)->eh_frame_hdr = sec;
1225 return TRUE;
1228 /* This function is called from size_dynamic_sections.
1229 It needs to decide whether .eh_frame_hdr should be output or not,
1230 because when the dynamic symbol table has been sized it is too late
1231 to strip sections. */
1233 bfd_boolean
1234 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1236 asection *o;
1237 bfd *abfd;
1238 struct elf_link_hash_table *htab;
1239 struct eh_frame_hdr_info *hdr_info;
1241 htab = elf_hash_table (info);
1242 hdr_info = &htab->eh_info;
1243 if (hdr_info->hdr_sec == NULL)
1244 return TRUE;
1246 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1248 hdr_info->hdr_sec = NULL;
1249 return TRUE;
1252 abfd = NULL;
1253 if (info->eh_frame_hdr)
1254 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1256 /* Count only sections which have at least a single CIE or FDE.
1257 There cannot be any CIE or FDE <= 8 bytes. */
1258 o = bfd_get_section_by_name (abfd, ".eh_frame");
1259 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1260 break;
1263 if (abfd == NULL)
1265 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1266 hdr_info->hdr_sec = NULL;
1267 return TRUE;
1270 hdr_info->table = TRUE;
1271 return TRUE;
1274 /* Adjust an address in the .eh_frame section. Given OFFSET within
1275 SEC, this returns the new offset in the adjusted .eh_frame section,
1276 or -1 if the address refers to a CIE/FDE which has been removed
1277 or to offset with dynamic relocation which is no longer needed. */
1279 bfd_vma
1280 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1281 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1282 asection *sec,
1283 bfd_vma offset)
1285 struct eh_frame_sec_info *sec_info;
1286 unsigned int lo, hi, mid;
1288 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1289 return offset;
1290 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1292 if (offset >= sec->rawsize)
1293 return offset - sec->rawsize + sec->size;
1295 lo = 0;
1296 hi = sec_info->count;
1297 mid = 0;
1298 while (lo < hi)
1300 mid = (lo + hi) / 2;
1301 if (offset < sec_info->entry[mid].offset)
1302 hi = mid;
1303 else if (offset
1304 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1305 lo = mid + 1;
1306 else
1307 break;
1310 BFD_ASSERT (lo < hi);
1312 /* FDE or CIE was removed. */
1313 if (sec_info->entry[mid].removed)
1314 return (bfd_vma) -1;
1316 /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1317 no need for run-time relocation against the personality field. */
1318 if (sec_info->entry[mid].cie
1319 && sec_info->entry[mid].u.cie.make_per_encoding_relative
1320 && offset == (sec_info->entry[mid].offset + 8
1321 + sec_info->entry[mid].u.cie.personality_offset))
1322 return (bfd_vma) -2;
1324 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1325 relocation against FDE's initial_location field. */
1326 if (!sec_info->entry[mid].cie
1327 && sec_info->entry[mid].make_relative
1328 && offset == sec_info->entry[mid].offset + 8)
1329 return (bfd_vma) -2;
1331 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1332 for run-time relocation against LSDA field. */
1333 if (!sec_info->entry[mid].cie
1334 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1335 && offset == (sec_info->entry[mid].offset + 8
1336 + sec_info->entry[mid].lsda_offset))
1337 return (bfd_vma) -2;
1339 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1340 relocation against DW_CFA_set_loc's arguments. */
1341 if (sec_info->entry[mid].set_loc
1342 && sec_info->entry[mid].make_relative
1343 && (offset >= sec_info->entry[mid].offset + 8
1344 + sec_info->entry[mid].set_loc[1]))
1346 unsigned int cnt;
1348 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1349 if (offset == sec_info->entry[mid].offset + 8
1350 + sec_info->entry[mid].set_loc[cnt])
1351 return (bfd_vma) -2;
1354 /* Any new augmentation bytes go before the first relocation. */
1355 return (offset + sec_info->entry[mid].new_offset
1356 - sec_info->entry[mid].offset
1357 + extra_augmentation_string_bytes (sec_info->entry + mid)
1358 + extra_augmentation_data_bytes (sec_info->entry + mid));
1361 /* Write out .eh_frame section. This is called with the relocated
1362 contents. */
1364 bfd_boolean
1365 _bfd_elf_write_section_eh_frame (bfd *abfd,
1366 struct bfd_link_info *info,
1367 asection *sec,
1368 bfd_byte *contents)
1370 struct eh_frame_sec_info *sec_info;
1371 struct elf_link_hash_table *htab;
1372 struct eh_frame_hdr_info *hdr_info;
1373 unsigned int ptr_size;
1374 struct eh_cie_fde *ent;
1376 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1377 /* FIXME: octets_per_byte. */
1378 return bfd_set_section_contents (abfd, sec->output_section, contents,
1379 sec->output_offset, sec->size);
1381 ptr_size = (get_elf_backend_data (abfd)
1382 ->elf_backend_eh_frame_address_size (abfd, sec));
1383 BFD_ASSERT (ptr_size != 0);
1385 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1386 htab = elf_hash_table (info);
1387 hdr_info = &htab->eh_info;
1389 if (hdr_info->table && hdr_info->array == NULL)
1390 hdr_info->array = (struct eh_frame_array_ent *)
1391 bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1392 if (hdr_info->array == NULL)
1393 hdr_info = NULL;
1395 /* The new offsets can be bigger or smaller than the original offsets.
1396 We therefore need to make two passes over the section: one backward
1397 pass to move entries up and one forward pass to move entries down.
1398 The two passes won't interfere with each other because entries are
1399 not reordered */
1400 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1401 if (!ent->removed && ent->new_offset > ent->offset)
1402 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1404 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
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)
1410 unsigned char *buf, *end;
1411 unsigned int new_size;
1413 if (ent->removed)
1414 continue;
1416 if (ent->size == 4)
1418 /* Any terminating FDE must be at the end of the section. */
1419 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1420 continue;
1423 buf = contents + ent->new_offset;
1424 end = buf + ent->size;
1425 new_size = size_of_output_cie_fde (ent, ptr_size);
1427 /* Update the size. It may be shrinked. */
1428 bfd_put_32 (abfd, new_size - 4, buf);
1430 /* Filling the extra bytes with DW_CFA_nops. */
1431 if (new_size != ent->size)
1432 memset (end, 0, new_size - ent->size);
1434 if (ent->cie)
1436 /* CIE */
1437 if (ent->make_relative
1438 || ent->u.cie.make_lsda_relative
1439 || ent->u.cie.per_encoding_relative)
1441 char *aug;
1442 unsigned int action, extra_string, extra_data;
1443 unsigned int per_width, per_encoding;
1445 /* Need to find 'R' or 'L' augmentation's argument and modify
1446 DW_EH_PE_* value. */
1447 action = ((ent->make_relative ? 1 : 0)
1448 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1449 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1450 extra_string = extra_augmentation_string_bytes (ent);
1451 extra_data = extra_augmentation_data_bytes (ent);
1453 /* Skip length, id and version. */
1454 buf += 9;
1455 aug = (char *) buf;
1456 buf += strlen (aug) + 1;
1457 skip_leb128 (&buf, end);
1458 skip_leb128 (&buf, end);
1459 skip_leb128 (&buf, end);
1460 if (*aug == 'z')
1462 /* The uleb128 will always be a single byte for the kind
1463 of augmentation strings that we're prepared to handle. */
1464 *buf++ += extra_data;
1465 aug++;
1468 /* Make room for the new augmentation string and data bytes. */
1469 memmove (buf + extra_string + extra_data, buf, end - buf);
1470 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1471 buf += extra_string;
1472 end += extra_string + extra_data;
1474 if (ent->add_augmentation_size)
1476 *aug++ = 'z';
1477 *buf++ = extra_data - 1;
1479 if (ent->u.cie.add_fde_encoding)
1481 BFD_ASSERT (action & 1);
1482 *aug++ = 'R';
1483 *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
1484 action &= ~1;
1487 while (action)
1488 switch (*aug++)
1490 case 'L':
1491 if (action & 2)
1493 BFD_ASSERT (*buf == ent->lsda_encoding);
1494 *buf = make_pc_relative (*buf, ptr_size);
1495 action &= ~2;
1497 buf++;
1498 break;
1499 case 'P':
1500 if (ent->u.cie.make_per_encoding_relative)
1501 *buf = make_pc_relative (*buf, ptr_size);
1502 per_encoding = *buf++;
1503 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1504 BFD_ASSERT (per_width != 0);
1505 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1506 == ent->u.cie.per_encoding_relative);
1507 if ((per_encoding & 0x70) == DW_EH_PE_aligned)
1508 buf = (contents
1509 + ((buf - contents + per_width - 1)
1510 & ~((bfd_size_type) per_width - 1)));
1511 if (action & 4)
1513 bfd_vma val;
1515 val = read_value (abfd, buf, per_width,
1516 get_DW_EH_PE_signed (per_encoding));
1517 if (ent->u.cie.make_per_encoding_relative)
1518 val -= (sec->output_section->vma
1519 + sec->output_offset
1520 + (buf - contents));
1521 else
1523 val += (bfd_vma) ent->offset - ent->new_offset;
1524 val -= extra_string + extra_data;
1526 write_value (abfd, buf, val, per_width);
1527 action &= ~4;
1529 buf += per_width;
1530 break;
1531 case 'R':
1532 if (action & 1)
1534 BFD_ASSERT (*buf == ent->fde_encoding);
1535 *buf = make_pc_relative (*buf, ptr_size);
1536 action &= ~1;
1538 buf++;
1539 break;
1540 case 'S':
1541 break;
1542 default:
1543 BFD_FAIL ();
1547 else
1549 /* FDE */
1550 bfd_vma value, address;
1551 unsigned int width;
1552 bfd_byte *start;
1553 struct eh_cie_fde *cie;
1555 /* Skip length. */
1556 cie = ent->u.fde.cie_inf;
1557 buf += 4;
1558 value = ((ent->new_offset + sec->output_offset + 4)
1559 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1560 bfd_put_32 (abfd, value, buf);
1561 buf += 4;
1562 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1563 value = read_value (abfd, buf, width,
1564 get_DW_EH_PE_signed (ent->fde_encoding));
1565 address = value;
1566 if (value)
1568 switch (ent->fde_encoding & 0x70)
1570 case DW_EH_PE_textrel:
1571 BFD_ASSERT (hdr_info == NULL);
1572 break;
1573 case DW_EH_PE_datarel:
1575 asection *got = bfd_get_section_by_name (abfd, ".got");
1577 BFD_ASSERT (got != NULL);
1578 address += got->vma;
1580 break;
1581 case DW_EH_PE_pcrel:
1582 value += (bfd_vma) ent->offset - ent->new_offset;
1583 address += (sec->output_section->vma
1584 + sec->output_offset
1585 + ent->offset + 8);
1586 break;
1588 if (ent->make_relative)
1589 value -= (sec->output_section->vma
1590 + sec->output_offset
1591 + ent->new_offset + 8);
1592 write_value (abfd, buf, value, width);
1595 start = buf;
1597 if (hdr_info)
1599 hdr_info->array[hdr_info->array_count].initial_loc = address;
1600 hdr_info->array[hdr_info->array_count++].fde
1601 = (sec->output_section->vma
1602 + sec->output_offset
1603 + ent->new_offset);
1606 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
1607 || cie->u.cie.make_lsda_relative)
1609 buf += ent->lsda_offset;
1610 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1611 value = read_value (abfd, buf, width,
1612 get_DW_EH_PE_signed (ent->lsda_encoding));
1613 if (value)
1615 if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1616 value += (bfd_vma) ent->offset - ent->new_offset;
1617 else if (cie->u.cie.make_lsda_relative)
1618 value -= (sec->output_section->vma
1619 + sec->output_offset
1620 + ent->new_offset + 8 + ent->lsda_offset);
1621 write_value (abfd, buf, value, width);
1624 else if (ent->add_augmentation_size)
1626 /* Skip the PC and length and insert a zero byte for the
1627 augmentation size. */
1628 buf += width * 2;
1629 memmove (buf + 1, buf, end - buf);
1630 *buf = 0;
1633 if (ent->set_loc)
1635 /* Adjust DW_CFA_set_loc. */
1636 unsigned int cnt;
1637 bfd_vma new_offset;
1639 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1640 new_offset = ent->new_offset + 8
1641 + extra_augmentation_string_bytes (ent)
1642 + extra_augmentation_data_bytes (ent);
1644 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1646 buf = start + ent->set_loc[cnt];
1648 value = read_value (abfd, buf, width,
1649 get_DW_EH_PE_signed (ent->fde_encoding));
1650 if (!value)
1651 continue;
1653 if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
1654 value += (bfd_vma) ent->offset + 8 - new_offset;
1655 if (ent->make_relative)
1656 value -= (sec->output_section->vma
1657 + sec->output_offset
1658 + new_offset + ent->set_loc[cnt]);
1659 write_value (abfd, buf, value, width);
1665 /* We don't align the section to its section alignment since the
1666 runtime library only expects all CIE/FDE records aligned at
1667 the pointer size. _bfd_elf_discard_section_eh_frame should
1668 have padded CIE/FDE records to multiple of pointer size with
1669 size_of_output_cie_fde. */
1670 if ((sec->size % ptr_size) != 0)
1671 abort ();
1673 /* FIXME: octets_per_byte. */
1674 return bfd_set_section_contents (abfd, sec->output_section,
1675 contents, (file_ptr) sec->output_offset,
1676 sec->size);
1679 /* Helper function used to sort .eh_frame_hdr search table by increasing
1680 VMA of FDE initial location. */
1682 static int
1683 vma_compare (const void *a, const void *b)
1685 const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
1686 const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
1687 if (p->initial_loc > q->initial_loc)
1688 return 1;
1689 if (p->initial_loc < q->initial_loc)
1690 return -1;
1691 return 0;
1694 /* Write out .eh_frame_hdr section. This must be called after
1695 _bfd_elf_write_section_eh_frame has been called on all input
1696 .eh_frame sections.
1697 .eh_frame_hdr format:
1698 ubyte version (currently 1)
1699 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1700 .eh_frame section)
1701 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1702 number (or DW_EH_PE_omit if there is no
1703 binary search table computed))
1704 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1705 or DW_EH_PE_omit if not present.
1706 DW_EH_PE_datarel is using address of
1707 .eh_frame_hdr section start as base)
1708 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1709 optionally followed by:
1710 [encoded] fde_count (total number of FDEs in .eh_frame section)
1711 fde_count x [encoded] initial_loc, fde
1712 (array of encoded pairs containing
1713 FDE initial_location field and FDE address,
1714 sorted by increasing initial_loc). */
1716 bfd_boolean
1717 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1719 struct elf_link_hash_table *htab;
1720 struct eh_frame_hdr_info *hdr_info;
1721 asection *sec;
1722 bfd_byte *contents;
1723 asection *eh_frame_sec;
1724 bfd_size_type size;
1725 bfd_boolean retval;
1726 bfd_vma encoded_eh_frame;
1728 htab = elf_hash_table (info);
1729 hdr_info = &htab->eh_info;
1730 sec = hdr_info->hdr_sec;
1731 if (sec == NULL)
1732 return TRUE;
1734 size = EH_FRAME_HDR_SIZE;
1735 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1736 size += 4 + hdr_info->fde_count * 8;
1737 contents = (bfd_byte *) bfd_malloc (size);
1738 if (contents == NULL)
1739 return FALSE;
1741 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1742 if (eh_frame_sec == NULL)
1744 free (contents);
1745 return FALSE;
1748 memset (contents, 0, EH_FRAME_HDR_SIZE);
1749 contents[0] = 1; /* Version. */
1750 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1751 (abfd, info, eh_frame_sec, 0, sec, 4,
1752 &encoded_eh_frame); /* .eh_frame offset. */
1754 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1756 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1757 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1759 else
1761 contents[2] = DW_EH_PE_omit;
1762 contents[3] = DW_EH_PE_omit;
1764 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1766 if (contents[2] != DW_EH_PE_omit)
1768 unsigned int i;
1770 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1771 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1772 vma_compare);
1773 for (i = 0; i < hdr_info->fde_count; i++)
1775 bfd_put_32 (abfd,
1776 hdr_info->array[i].initial_loc
1777 - sec->output_section->vma,
1778 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1779 bfd_put_32 (abfd,
1780 hdr_info->array[i].fde - sec->output_section->vma,
1781 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1785 /* FIXME: octets_per_byte. */
1786 retval = bfd_set_section_contents (abfd, sec->output_section,
1787 contents, (file_ptr) sec->output_offset,
1788 sec->size);
1789 free (contents);
1790 return retval;
1793 /* Return the width of FDE addresses. This is the default implementation. */
1795 unsigned int
1796 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1798 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1801 /* Decide whether we can use a PC-relative encoding within the given
1802 EH frame section. This is the default implementation. */
1804 bfd_boolean
1805 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1806 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1807 asection *eh_frame_section ATTRIBUTE_UNUSED)
1809 return TRUE;
1812 /* Select an encoding for the given address. Preference is given to
1813 PC-relative addressing modes. */
1815 bfd_byte
1816 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1817 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1818 asection *osec, bfd_vma offset,
1819 asection *loc_sec, bfd_vma loc_offset,
1820 bfd_vma *encoded)
1822 *encoded = osec->vma + offset -
1823 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1824 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;