projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* configure.in: Remove elf-ifunc.lo from common ELF files. Add
[deliverable/binutils-gdb.git] / bfd / elf-eh-frame.c
... / ...
CommitLineData
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>.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
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.
12
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.
17
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. */
22
23#include "sysdep.h"
24#include "bfd.h"
25#include "libbfd.h"
26#include "elf-bfd.h"
27#include "dwarf2.h"
28
29#define EH_FRAME_HDR_SIZE 8
30
31struct cie
32{
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];
55};
56
57
58
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. */
61
62static inline bfd_boolean
63read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
64{
65 if (*iter >= end)
66 return FALSE;
67 *result = *((*iter)++);
68 return TRUE;
69}
70
71/* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
72 Return true it was possible to move LENGTH bytes. */
73
74static inline bfd_boolean
75skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
76{
77 if ((bfd_size_type) (end - *iter) < length)
78 {
79 *iter = end;
80 return FALSE;
81 }
82 *iter += length;
83 return TRUE;
84}
85
86/* Move *ITER over an leb128, stopping at END. Return true if the end
87 of the leb128 was found. */
88
89static bfd_boolean
90skip_leb128 (bfd_byte **iter, bfd_byte *end)
91{
92 unsigned char byte;
93 do
94 if (!read_byte (iter, end, &byte))
95 return FALSE;
96 while (byte & 0x80);
97 return TRUE;
98}
99
100/* Like skip_leb128, but treat the leb128 as an unsigned value and
101 store it in *VALUE. */
102
103static bfd_boolean
104read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
105{
106 bfd_byte *start, *p;
107
108 start = *iter;
109 if (!skip_leb128 (iter, end))
110 return FALSE;
111
112 p = *iter;
113 *value = *--p;
114 while (p > start)
115 *value = (*value << 7) | (*--p & 0x7f);
116
117 return TRUE;
118}
119
120/* Like read_uleb128, but for signed values. */
121
122static bfd_boolean
123read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
124{
125 bfd_byte *start, *p;
126
127 start = *iter;
128 if (!skip_leb128 (iter, end))
129 return FALSE;
130
131 p = *iter;
132 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
133 while (p > start)
134 *value = (*value << 7) | (*--p & 0x7f);
135
136 return TRUE;
137}
138
139/* Return 0 if either encoding is variable width, or not yet known to bfd. */
140
141static
142int get_DW_EH_PE_width (int encoding, int ptr_size)
143{
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;
148
149 switch (encoding & 7)
150 {
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;
157 }
158
159 return 0;
160}
161
162#define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
163
164/* Read a width sized value from memory. */
165
166static bfd_vma
167read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
168{
169 bfd_vma value;
170
171 switch (width)
172 {
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;
194 }
195
196 return value;
197}
198
199/* Store a width sized value to memory. */
200
201static void
202write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
203{
204 switch (width)
205 {
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 ();
210 }
211}
212
213/* Return one if C1 and C2 CIEs can be merged. */
214
215static int
216cie_eq (const void *e1, const void *e2)
217{
218 const struct cie *c1 = e1;
219 const struct cie *c2 = e2;
220
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;
242
243 return 0;
244}
245
246static hashval_t
247cie_hash (const void *e)
248{
249 const struct cie *c = e;
250 return c->hash;
251}
252
253static hashval_t
254cie_compute_hash (struct cie *c)
255{
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;
273}
274
275/* Return the number of extra bytes that we'll be inserting into
276 ENTRY's augmentation string. */
277
278static INLINE unsigned int
279extra_augmentation_string_bytes (struct eh_cie_fde *entry)
280{
281 unsigned int size = 0;
282 if (entry->cie)
283 {
284 if (entry->add_augmentation_size)
285 size++;
286 if (entry->u.cie.add_fde_encoding)
287 size++;
288 }
289 return size;
290}
291
292/* Likewise ENTRY's augmentation data. */
293
294static INLINE unsigned int
295extra_augmentation_data_bytes (struct eh_cie_fde *entry)
296{
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;
303}
304
305/* Return the size that ENTRY will have in the output. ALIGNMENT is the
306 required alignment of ENTRY in bytes. */
307
308static unsigned int
309size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
310{
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;
319}
320
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. */
324
325static bfd_boolean
326skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
327{
328 bfd_byte op;
329 bfd_vma length;
330
331 if (!read_byte (iter, end, &op))
332 return FALSE;
333
334 switch (op & 0xc0 ? op & 0xc0 : op)
335 {
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;
344
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);
355
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));
367
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));
372
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));
379
380 case DW_CFA_set_loc:
381 return skip_bytes (iter, end, encoded_ptr_width);
382
383 case DW_CFA_advance_loc1:
384 return skip_bytes (iter, end, 1);
385
386 case DW_CFA_advance_loc2:
387 return skip_bytes (iter, end, 2);
388
389 case DW_CFA_advance_loc4:
390 return skip_bytes (iter, end, 4);
391
392 case DW_CFA_MIPS_advance_loc8:
393 return skip_bytes (iter, end, 8);
394
395 default:
396 return FALSE;
397 }
398}
399
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. */
404
405static bfd_byte *
406skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
407 unsigned int *set_loc_count)
408{
409 bfd_byte *last;
410
411 last = buf;
412 while (buf < end)
413 if (*buf == DW_CFA_nop)
414 buf++;
415 else
416 {
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;
422 }
423 return last;
424}
425
426/* Called before calling _bfd_elf_parse_eh_frame on every input bfd's
427 .eh_frame section. */
428
429void
430_bfd_elf_begin_eh_frame_parsing (struct bfd_link_info *info)
431{
432 struct eh_frame_hdr_info *hdr_info;
433
434 hdr_info = &elf_hash_table (info)->eh_info;
435 hdr_info->merge_cies = !info->relocatable;
436}
437
438/* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
439 information in the section's sec_info field on success. COOKIE
440 describes the relocations in SEC. */
441
442void
443_bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
444 asection *sec, struct elf_reloc_cookie *cookie)
445{
446#define REQUIRE(COND) \
447 do \
448 if (!(COND)) \
449 goto free_no_table; \
450 while (0)
451
452 bfd_byte *ehbuf = NULL, *buf, *end;
453 bfd_byte *last_fde;
454 struct eh_cie_fde *this_inf;
455 unsigned int hdr_length, hdr_id;
456 unsigned int cie_count;
457 struct cie *cie, *local_cies = NULL;
458 struct elf_link_hash_table *htab;
459 struct eh_frame_hdr_info *hdr_info;
460 struct eh_frame_sec_info *sec_info = NULL;
461 unsigned int ptr_size;
462 unsigned int num_cies;
463 unsigned int num_entries;
464 elf_gc_mark_hook_fn gc_mark_hook;
465
466 htab = elf_hash_table (info);
467 hdr_info = &htab->eh_info;
468 if (hdr_info->parsed_eh_frames)
469 return;
470
471 if (sec->size == 0)
472 {
473 /* This file does not contain .eh_frame information. */
474 return;
475 }
476
477 if (bfd_is_abs_section (sec->output_section))
478 {
479 /* At least one of the sections is being discarded from the
480 link, so we should just ignore them. */
481 return;
482 }
483
484 /* Read the frame unwind information from abfd. */
485
486 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
487
488 if (sec->size >= 4
489 && bfd_get_32 (abfd, ehbuf) == 0
490 && cookie->rel == cookie->relend)
491 {
492 /* Empty .eh_frame section. */
493 free (ehbuf);
494 return;
495 }
496
497 /* If .eh_frame section size doesn't fit into int, we cannot handle
498 it (it would need to use 64-bit .eh_frame format anyway). */
499 REQUIRE (sec->size == (unsigned int) sec->size);
500
501 ptr_size = (get_elf_backend_data (abfd)
502 ->elf_backend_eh_frame_address_size (abfd, sec));
503 REQUIRE (ptr_size != 0);
504
505 /* Go through the section contents and work out how many FDEs and
506 CIEs there are. */
507 buf = ehbuf;
508 end = ehbuf + sec->size;
509 num_cies = 0;
510 num_entries = 0;
511 while (buf != end)
512 {
513 num_entries++;
514
515 /* Read the length of the entry. */
516 REQUIRE (skip_bytes (&buf, end, 4));
517 hdr_length = bfd_get_32 (abfd, buf - 4);
518
519 /* 64-bit .eh_frame is not supported. */
520 REQUIRE (hdr_length != 0xffffffff);
521 if (hdr_length == 0)
522 break;
523
524 REQUIRE (skip_bytes (&buf, end, 4));
525 hdr_id = bfd_get_32 (abfd, buf - 4);
526 if (hdr_id == 0)
527 num_cies++;
528
529 REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
530 }
531
532 sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
533 + (num_entries - 1) * sizeof (struct eh_cie_fde));
534 REQUIRE (sec_info);
535
536 /* We need to have a "struct cie" for each CIE in this section. */
537 local_cies = bfd_zmalloc (num_cies * sizeof (*local_cies));
538 REQUIRE (local_cies);
539
540#define ENSURE_NO_RELOCS(buf) \
541 REQUIRE (!(cookie->rel < cookie->relend \
542 && (cookie->rel->r_offset \
543 < (bfd_size_type) ((buf) - ehbuf)) \
544 && cookie->rel->r_info != 0))
545
546#define SKIP_RELOCS(buf) \
547 while (cookie->rel < cookie->relend \
548 && (cookie->rel->r_offset \
549 < (bfd_size_type) ((buf) - ehbuf))) \
550 cookie->rel++
551
552#define GET_RELOC(buf) \
553 ((cookie->rel < cookie->relend \
554 && (cookie->rel->r_offset \
555 == (bfd_size_type) ((buf) - ehbuf))) \
556 ? cookie->rel : NULL)
557
558 buf = ehbuf;
559 cie_count = 0;
560 gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
561 while ((bfd_size_type) (buf - ehbuf) != sec->size)
562 {
563 char *aug;
564 bfd_byte *start, *insns, *insns_end;
565 bfd_size_type length;
566 unsigned int set_loc_count;
567
568 this_inf = sec_info->entry + sec_info->count;
569 last_fde = buf;
570
571 /* Read the length of the entry. */
572 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
573 hdr_length = bfd_get_32 (abfd, buf - 4);
574
575 /* The CIE/FDE must be fully contained in this input section. */
576 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
577 end = buf + hdr_length;
578
579 this_inf->offset = last_fde - ehbuf;
580 this_inf->size = 4 + hdr_length;
581 this_inf->reloc_index = cookie->rel - cookie->rels;
582
583 if (hdr_length == 0)
584 {
585 /* A zero-length CIE should only be found at the end of
586 the section. */
587 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
588 ENSURE_NO_RELOCS (buf);
589 sec_info->count++;
590 break;
591 }
592
593 REQUIRE (skip_bytes (&buf, end, 4));
594 hdr_id = bfd_get_32 (abfd, buf - 4);
595
596 if (hdr_id == 0)
597 {
598 unsigned int initial_insn_length;
599
600 /* CIE */
601 this_inf->cie = 1;
602
603 /* Point CIE to one of the section-local cie structures. */
604 cie = local_cies + cie_count++;
605
606 cie->cie_inf = this_inf;
607 cie->length = hdr_length;
608 cie->output_sec = sec->output_section;
609 start = buf;
610 REQUIRE (read_byte (&buf, end, &cie->version));
611
612 /* Cannot handle unknown versions. */
613 REQUIRE (cie->version == 1 || cie->version == 3);
614 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
615
616 strcpy (cie->augmentation, (char *) buf);
617 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
618 ENSURE_NO_RELOCS (buf);
619 if (buf[0] == 'e' && buf[1] == 'h')
620 {
621 /* GCC < 3.0 .eh_frame CIE */
622 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
623 is private to each CIE, so we don't need it for anything.
624 Just skip it. */
625 REQUIRE (skip_bytes (&buf, end, ptr_size));
626 SKIP_RELOCS (buf);
627 }
628 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
629 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
630 if (cie->version == 1)
631 {
632 REQUIRE (buf < end);
633 cie->ra_column = *buf++;
634 }
635 else
636 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
637 ENSURE_NO_RELOCS (buf);
638 cie->lsda_encoding = DW_EH_PE_omit;
639 cie->fde_encoding = DW_EH_PE_omit;
640 cie->per_encoding = DW_EH_PE_omit;
641 aug = cie->augmentation;
642 if (aug[0] != 'e' || aug[1] != 'h')
643 {
644 if (*aug == 'z')
645 {
646 aug++;
647 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
648 ENSURE_NO_RELOCS (buf);
649 }
650
651 while (*aug != '\0')
652 switch (*aug++)
653 {
654 case 'L':
655 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
656 ENSURE_NO_RELOCS (buf);
657 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
658 break;
659 case 'R':
660 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
661 ENSURE_NO_RELOCS (buf);
662 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
663 break;
664 case 'S':
665 break;
666 case 'P':
667 {
668 int per_width;
669
670 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
671 per_width = get_DW_EH_PE_width (cie->per_encoding,
672 ptr_size);
673 REQUIRE (per_width);
674 if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
675 {
676 length = -(buf - ehbuf) & (per_width - 1);
677 REQUIRE (skip_bytes (&buf, end, length));
678 }
679 ENSURE_NO_RELOCS (buf);
680 /* Ensure we have a reloc here. */
681 REQUIRE (GET_RELOC (buf));
682 cie->personality.reloc_index
683 = cookie->rel - cookie->rels;
684 /* Cope with MIPS-style composite relocations. */
685 do
686 cookie->rel++;
687 while (GET_RELOC (buf) != NULL);
688 REQUIRE (skip_bytes (&buf, end, per_width));
689 }
690 break;
691 default:
692 /* Unrecognized augmentation. Better bail out. */
693 goto free_no_table;
694 }
695 }
696
697 /* For shared libraries, try to get rid of as many RELATIVE relocs
698 as possible. */
699 if (info->shared
700 && (get_elf_backend_data (abfd)
701 ->elf_backend_can_make_relative_eh_frame
702 (abfd, info, sec)))
703 {
704 if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
705 this_inf->make_relative = 1;
706 /* If the CIE doesn't already have an 'R' entry, it's fairly
707 easy to add one, provided that there's no aligned data
708 after the augmentation string. */
709 else if (cie->fde_encoding == DW_EH_PE_omit
710 && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
711 {
712 if (*cie->augmentation == 0)
713 this_inf->add_augmentation_size = 1;
714 this_inf->u.cie.add_fde_encoding = 1;
715 this_inf->make_relative = 1;
716 }
717 }
718
719 if (info->shared
720 && (get_elf_backend_data (abfd)
721 ->elf_backend_can_make_lsda_relative_eh_frame
722 (abfd, info, sec))
723 && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
724 cie->can_make_lsda_relative = 1;
725
726 /* If FDE encoding was not specified, it defaults to
727 DW_EH_absptr. */
728 if (cie->fde_encoding == DW_EH_PE_omit)
729 cie->fde_encoding = DW_EH_PE_absptr;
730
731 initial_insn_length = end - buf;
732 if (initial_insn_length <= sizeof (cie->initial_instructions))
733 {
734 cie->initial_insn_length = initial_insn_length;
735 memcpy (cie->initial_instructions, buf, initial_insn_length);
736 }
737 insns = buf;
738 buf += initial_insn_length;
739 ENSURE_NO_RELOCS (buf);
740
741 if (hdr_info->merge_cies)
742 this_inf->u.cie.u.full_cie = cie;
743 this_inf->u.cie.per_encoding_relative
744 = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
745 }
746 else
747 {
748 asection *rsec;
749
750 /* Find the corresponding CIE. */
751 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
752 for (cie = local_cies; cie < local_cies + cie_count; cie++)
753 if (cie_offset == cie->cie_inf->offset)
754 break;
755
756 /* Ensure this FDE references one of the CIEs in this input
757 section. */
758 REQUIRE (cie != local_cies + cie_count);
759 this_inf->u.fde.cie_inf = cie->cie_inf;
760 this_inf->make_relative = cie->cie_inf->make_relative;
761 this_inf->add_augmentation_size
762 = cie->cie_inf->add_augmentation_size;
763
764 ENSURE_NO_RELOCS (buf);
765 REQUIRE (GET_RELOC (buf));
766
767 /* Chain together the FDEs for each section. */
768 rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook, cookie);
769 /* RSEC will be NULL if FDE was cleared out as it was belonging to
770 a discarded SHT_GROUP. */
771 if (rsec)
772 {
773 REQUIRE (rsec->owner == abfd);
774 this_inf->u.fde.next_for_section = elf_fde_list (rsec);
775 elf_fde_list (rsec) = this_inf;
776 }
777
778 /* Skip the initial location and address range. */
779 start = buf;
780 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
781 REQUIRE (skip_bytes (&buf, end, 2 * length));
782
783 /* Skip the augmentation size, if present. */
784 if (cie->augmentation[0] == 'z')
785 REQUIRE (read_uleb128 (&buf, end, &length));
786 else
787 length = 0;
788
789 /* Of the supported augmentation characters above, only 'L'
790 adds augmentation data to the FDE. This code would need to
791 be adjusted if any future augmentations do the same thing. */
792 if (cie->lsda_encoding != DW_EH_PE_omit)
793 {
794 SKIP_RELOCS (buf);
795 if (cie->can_make_lsda_relative && GET_RELOC (buf))
796 cie->cie_inf->u.cie.make_lsda_relative = 1;
797 this_inf->lsda_offset = buf - start;
798 /* If there's no 'z' augmentation, we don't know where the
799 CFA insns begin. Assume no padding. */
800 if (cie->augmentation[0] != 'z')
801 length = end - buf;
802 }
803
804 /* Skip over the augmentation data. */
805 REQUIRE (skip_bytes (&buf, end, length));
806 insns = buf;
807
808 buf = last_fde + 4 + hdr_length;
809
810 /* For NULL RSEC (cleared FDE belonging to a discarded section)
811 the relocations are commonly cleared. We do not sanity check if
812 all these relocations are cleared as (1) relocations to
813 .gcc_except_table will remain uncleared (they will get dropped
814 with the drop of this unused FDE) and (2) BFD already safely drops
815 relocations of any type to .eh_frame by
816 elf_section_ignore_discarded_relocs.
817 TODO: The .gcc_except_table entries should be also filtered as
818 .eh_frame entries; or GCC could rather use COMDAT for them. */
819 SKIP_RELOCS (buf);
820 }
821
822 /* Try to interpret the CFA instructions and find the first
823 padding nop. Shrink this_inf's size so that it doesn't
824 include the padding. */
825 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
826 set_loc_count = 0;
827 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
828 /* If we don't understand the CFA instructions, we can't know
829 what needs to be adjusted there. */
830 if (insns_end == NULL
831 /* For the time being we don't support DW_CFA_set_loc in
832 CIE instructions. */
833 || (set_loc_count && this_inf->cie))
834 goto free_no_table;
835 this_inf->size -= end - insns_end;
836 if (insns_end != end && this_inf->cie)
837 {
838 cie->initial_insn_length -= end - insns_end;
839 cie->length -= end - insns_end;
840 }
841 if (set_loc_count
842 && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
843 || this_inf->make_relative))
844 {
845 unsigned int cnt;
846 bfd_byte *p;
847
848 this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
849 * sizeof (unsigned int));
850 REQUIRE (this_inf->set_loc);
851 this_inf->set_loc[0] = set_loc_count;
852 p = insns;
853 cnt = 0;
854 while (p < end)
855 {
856 if (*p == DW_CFA_set_loc)
857 this_inf->set_loc[++cnt] = p + 1 - start;
858 REQUIRE (skip_cfa_op (&p, end, length));
859 }
860 }
861
862 this_inf->removed = 1;
863 this_inf->fde_encoding = cie->fde_encoding;
864 this_inf->lsda_encoding = cie->lsda_encoding;
865 sec_info->count++;
866 }
867 BFD_ASSERT (sec_info->count == num_entries);
868 BFD_ASSERT (cie_count == num_cies);
869
870 elf_section_data (sec)->sec_info = sec_info;
871 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
872 if (hdr_info->merge_cies)
873 {
874 sec_info->cies = local_cies;
875 local_cies = NULL;
876 }
877 goto success;
878
879 free_no_table:
880 (*info->callbacks->einfo)
881 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
882 abfd, sec);
883 hdr_info->table = FALSE;
884 if (sec_info)
885 free (sec_info);
886 success:
887 if (ehbuf)
888 free (ehbuf);
889 if (local_cies)
890 free (local_cies);
891#undef REQUIRE
892}
893
894/* Finish a pass over all .eh_frame sections. */
895
896void
897_bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
898{
899 struct eh_frame_hdr_info *hdr_info;
900
901 hdr_info = &elf_hash_table (info)->eh_info;
902 hdr_info->parsed_eh_frames = TRUE;
903}
904
905/* Mark all relocations against CIE or FDE ENT, which occurs in
906 .eh_frame section SEC. COOKIE describes the relocations in SEC;
907 its "rel" field can be changed freely. */
908
909static bfd_boolean
910mark_entry (struct bfd_link_info *info, asection *sec,
911 struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
912 struct elf_reloc_cookie *cookie)
913{
914 for (cookie->rel = cookie->rels + ent->reloc_index;
915 cookie->rel < cookie->relend
916 && cookie->rel->r_offset < ent->offset + ent->size;
917 cookie->rel++)
918 if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
919 return FALSE;
920
921 return TRUE;
922}
923
924/* Mark all the relocations against FDEs that relate to code in input
925 section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
926 relocations are described by COOKIE. */
927
928bfd_boolean
929_bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
930 asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
931 struct elf_reloc_cookie *cookie)
932{
933 struct eh_cie_fde *fde, *cie;
934
935 for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
936 {
937 if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
938 return FALSE;
939
940 /* At this stage, all cie_inf fields point to local CIEs, so we
941 can use the same cookie to refer to them. */
942 cie = fde->u.fde.cie_inf;
943 if (!cie->u.cie.gc_mark)
944 {
945 cie->u.cie.gc_mark = 1;
946 if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
947 return FALSE;
948 }
949 }
950 return TRUE;
951}
952
953/* Input section SEC of ABFD is an .eh_frame section that contains the
954 CIE described by CIE_INF. Return a version of CIE_INF that is going
955 to be kept in the output, adding CIE_INF to the output if necessary.
956
957 HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
958 relocations in REL. */
959
960static struct eh_cie_fde *
961find_merged_cie (bfd *abfd, asection *sec,
962 struct eh_frame_hdr_info *hdr_info,
963 struct elf_reloc_cookie *cookie,
964 struct eh_cie_fde *cie_inf)
965{
966 unsigned long r_symndx;
967 struct cie *cie, *new_cie;
968 Elf_Internal_Rela *rel;
969 void **loc;
970
971 /* Use CIE_INF if we have already decided to keep it. */
972 if (!cie_inf->removed)
973 return cie_inf;
974
975 /* If we have merged CIE_INF with another CIE, use that CIE instead. */
976 if (cie_inf->u.cie.merged)
977 return cie_inf->u.cie.u.merged_with;
978
979 cie = cie_inf->u.cie.u.full_cie;
980
981 /* Assume we will need to keep CIE_INF. */
982 cie_inf->removed = 0;
983 cie_inf->u.cie.u.sec = sec;
984
985 /* If we are not merging CIEs, use CIE_INF. */
986 if (cie == NULL)
987 return cie_inf;
988
989 if (cie->per_encoding != DW_EH_PE_omit)
990 {
991 /* Work out the address of personality routine, either as an absolute
992 value or as a symbol. */
993 rel = cookie->rels + cie->personality.reloc_index;
994 memset (&cie->personality, 0, sizeof (cie->personality));
995#ifdef BFD64
996 if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
997 r_symndx = ELF64_R_SYM (rel->r_info);
998 else
999#endif
1000 r_symndx = ELF32_R_SYM (rel->r_info);
1001 if (r_symndx >= cookie->locsymcount
1002 || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1003 {
1004 struct elf_link_hash_entry *h;
1005
1006 r_symndx -= cookie->extsymoff;
1007 h = cookie->sym_hashes[r_symndx];
1008
1009 while (h->root.type == bfd_link_hash_indirect
1010 || h->root.type == bfd_link_hash_warning)
1011 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1012
1013 cie->personality.h = h;
1014 }
1015 else
1016 {
1017 Elf_Internal_Sym *sym;
1018 asection *sym_sec;
1019
1020 sym = &cookie->locsyms[r_symndx];
1021 sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1022 if (sym_sec == NULL)
1023 return cie_inf;
1024
1025 if (sym_sec->kept_section != NULL)
1026 sym_sec = sym_sec->kept_section;
1027 if (sym_sec->output_section == NULL)
1028 return cie_inf;
1029
1030 cie->local_personality = 1;
1031 cie->personality.val = (sym->st_value
1032 + sym_sec->output_offset
1033 + sym_sec->output_section->vma);
1034 }
1035 }
1036
1037 /* See if we can merge this CIE with an earlier one. */
1038 cie->output_sec = sec->output_section;
1039 cie_compute_hash (cie);
1040 if (hdr_info->cies == NULL)
1041 {
1042 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
1043 if (hdr_info->cies == NULL)
1044 return cie_inf;
1045 }
1046 loc = htab_find_slot_with_hash (hdr_info->cies, cie, cie->hash, INSERT);
1047 if (loc == NULL)
1048 return cie_inf;
1049
1050 new_cie = (struct cie *) *loc;
1051 if (new_cie == NULL)
1052 {
1053 /* Keep CIE_INF and record it in the hash table. */
1054 new_cie = malloc (sizeof (struct cie));
1055 if (new_cie == NULL)
1056 return cie_inf;
1057
1058 memcpy (new_cie, cie, sizeof (struct cie));
1059 *loc = new_cie;
1060 }
1061 else
1062 {
1063 /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1064 cie_inf->removed = 1;
1065 cie_inf->u.cie.merged = 1;
1066 cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1067 if (cie_inf->u.cie.make_lsda_relative)
1068 new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1069 }
1070 return new_cie->cie_inf;
1071}
1072
1073/* This function is called for each input file before the .eh_frame
1074 section is relocated. It discards duplicate CIEs and FDEs for discarded
1075 functions. The function returns TRUE iff any entries have been
1076 deleted. */
1077
1078bfd_boolean
1079_bfd_elf_discard_section_eh_frame
1080 (bfd *abfd, struct bfd_link_info *info, asection *sec,
1081 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1082 struct elf_reloc_cookie *cookie)
1083{
1084 struct eh_cie_fde *ent;
1085 struct eh_frame_sec_info *sec_info;
1086 struct eh_frame_hdr_info *hdr_info;
1087 unsigned int ptr_size, offset;
1088
1089 sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1090 if (sec_info == NULL)
1091 return FALSE;
1092
1093 hdr_info = &elf_hash_table (info)->eh_info;
1094 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1095 if (ent->size == 4)
1096 /* There should only be one zero terminator, on the last input
1097 file supplying .eh_frame (crtend.o). Remove any others. */
1098 ent->removed = sec->map_head.s != NULL;
1099 else if (!ent->cie)
1100 {
1101 cookie->rel = cookie->rels + ent->reloc_index;
1102 BFD_ASSERT (cookie->rel < cookie->relend
1103 && cookie->rel->r_offset == ent->offset + 8);
1104 if (!(*reloc_symbol_deleted_p) (ent->offset + 8, cookie))
1105 {
1106 if (info->shared
1107 && (((ent->fde_encoding & 0xf0) == DW_EH_PE_absptr
1108 && ent->make_relative == 0)
1109 || (ent->fde_encoding & 0xf0) == DW_EH_PE_aligned))
1110 {
1111 /* If a shared library uses absolute pointers
1112 which we cannot turn into PC relative,
1113 don't create the binary search table,
1114 since it is affected by runtime relocations. */
1115 hdr_info->table = FALSE;
1116 (*info->callbacks->einfo)
1117 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
1118 " table being created.\n"), abfd, sec);
1119 }
1120 ent->removed = 0;
1121 hdr_info->fde_count++;
1122 ent->u.fde.cie_inf = find_merged_cie (abfd, sec, hdr_info, cookie,
1123 ent->u.fde.cie_inf);
1124 }
1125 }
1126
1127 if (sec_info->cies)
1128 {
1129 free (sec_info->cies);
1130 sec_info->cies = NULL;
1131 }
1132
1133 ptr_size = (get_elf_backend_data (sec->owner)
1134 ->elf_backend_eh_frame_address_size (sec->owner, sec));
1135 offset = 0;
1136 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1137 if (!ent->removed)
1138 {
1139 ent->new_offset = offset;
1140 offset += size_of_output_cie_fde (ent, ptr_size);
1141 }
1142
1143 sec->rawsize = sec->size;
1144 sec->size = offset;
1145 return offset != sec->rawsize;
1146}
1147
1148/* This function is called for .eh_frame_hdr section after
1149 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1150 input sections. It finalizes the size of .eh_frame_hdr section. */
1151
1152bfd_boolean
1153_bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1154{
1155 struct elf_link_hash_table *htab;
1156 struct eh_frame_hdr_info *hdr_info;
1157 asection *sec;
1158
1159 htab = elf_hash_table (info);
1160 hdr_info = &htab->eh_info;
1161
1162 if (hdr_info->cies != NULL)
1163 {
1164 htab_delete (hdr_info->cies);
1165 hdr_info->cies = NULL;
1166 }
1167
1168 sec = hdr_info->hdr_sec;
1169 if (sec == NULL)
1170 return FALSE;
1171
1172 sec->size = EH_FRAME_HDR_SIZE;
1173 if (hdr_info->table)
1174 sec->size += 4 + hdr_info->fde_count * 8;
1175
1176 elf_tdata (abfd)->eh_frame_hdr = sec;
1177 return TRUE;
1178}
1179
1180/* This function is called from size_dynamic_sections.
1181 It needs to decide whether .eh_frame_hdr should be output or not,
1182 because when the dynamic symbol table has been sized it is too late
1183 to strip sections. */
1184
1185bfd_boolean
1186_bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1187{
1188 asection *o;
1189 bfd *abfd;
1190 struct elf_link_hash_table *htab;
1191 struct eh_frame_hdr_info *hdr_info;
1192
1193 htab = elf_hash_table (info);
1194 hdr_info = &htab->eh_info;
1195 if (hdr_info->hdr_sec == NULL)
1196 return TRUE;
1197
1198 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1199 {
1200 hdr_info->hdr_sec = NULL;
1201 return TRUE;
1202 }
1203
1204 abfd = NULL;
1205 if (info->eh_frame_hdr)
1206 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1207 {
1208 /* Count only sections which have at least a single CIE or FDE.
1209 There cannot be any CIE or FDE <= 8 bytes. */
1210 o = bfd_get_section_by_name (abfd, ".eh_frame");
1211 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1212 break;
1213 }
1214
1215 if (abfd == NULL)
1216 {
1217 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1218 hdr_info->hdr_sec = NULL;
1219 return TRUE;
1220 }
1221
1222 hdr_info->table = TRUE;
1223 return TRUE;
1224}
1225
1226/* Adjust an address in the .eh_frame section. Given OFFSET within
1227 SEC, this returns the new offset in the adjusted .eh_frame section,
1228 or -1 if the address refers to a CIE/FDE which has been removed
1229 or to offset with dynamic relocation which is no longer needed. */
1230
1231bfd_vma
1232_bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1233 struct bfd_link_info *info,
1234 asection *sec,
1235 bfd_vma offset)
1236{
1237 struct eh_frame_sec_info *sec_info;
1238 struct elf_link_hash_table *htab;
1239 struct eh_frame_hdr_info *hdr_info;
1240 unsigned int lo, hi, mid;
1241
1242 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1243 return offset;
1244 sec_info = elf_section_data (sec)->sec_info;
1245
1246 if (offset >= sec->rawsize)
1247 return offset - sec->rawsize + sec->size;
1248
1249 htab = elf_hash_table (info);
1250 hdr_info = &htab->eh_info;
1251
1252 lo = 0;
1253 hi = sec_info->count;
1254 mid = 0;
1255 while (lo < hi)
1256 {
1257 mid = (lo + hi) / 2;
1258 if (offset < sec_info->entry[mid].offset)
1259 hi = mid;
1260 else if (offset
1261 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1262 lo = mid + 1;
1263 else
1264 break;
1265 }
1266
1267 BFD_ASSERT (lo < hi);
1268
1269 /* FDE or CIE was removed. */
1270 if (sec_info->entry[mid].removed)
1271 return (bfd_vma) -1;
1272
1273 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1274 relocation against FDE's initial_location field. */
1275 if (!sec_info->entry[mid].cie
1276 && sec_info->entry[mid].make_relative
1277 && offset == sec_info->entry[mid].offset + 8)
1278 return (bfd_vma) -2;
1279
1280 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1281 for run-time relocation against LSDA field. */
1282 if (!sec_info->entry[mid].cie
1283 && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1284 && offset == (sec_info->entry[mid].offset + 8
1285 + sec_info->entry[mid].lsda_offset))
1286 return (bfd_vma) -2;
1287
1288 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1289 relocation against DW_CFA_set_loc's arguments. */
1290 if (sec_info->entry[mid].set_loc
1291 && sec_info->entry[mid].make_relative
1292 && (offset >= sec_info->entry[mid].offset + 8
1293 + sec_info->entry[mid].set_loc[1]))
1294 {
1295 unsigned int cnt;
1296
1297 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1298 if (offset == sec_info->entry[mid].offset + 8
1299 + sec_info->entry[mid].set_loc[cnt])
1300 return (bfd_vma) -2;
1301 }
1302
1303 /* Any new augmentation bytes go before the first relocation. */
1304 return (offset + sec_info->entry[mid].new_offset
1305 - sec_info->entry[mid].offset
1306 + extra_augmentation_string_bytes (sec_info->entry + mid)
1307 + extra_augmentation_data_bytes (sec_info->entry + mid));
1308}
1309
1310/* Write out .eh_frame section. This is called with the relocated
1311 contents. */
1312
1313bfd_boolean
1314_bfd_elf_write_section_eh_frame (bfd *abfd,
1315 struct bfd_link_info *info,
1316 asection *sec,
1317 bfd_byte *contents)
1318{
1319 struct eh_frame_sec_info *sec_info;
1320 struct elf_link_hash_table *htab;
1321 struct eh_frame_hdr_info *hdr_info;
1322 unsigned int ptr_size;
1323 struct eh_cie_fde *ent;
1324
1325 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1326 return bfd_set_section_contents (abfd, sec->output_section, contents,
1327 sec->output_offset, sec->size);
1328
1329 ptr_size = (get_elf_backend_data (abfd)
1330 ->elf_backend_eh_frame_address_size (abfd, sec));
1331 BFD_ASSERT (ptr_size != 0);
1332
1333 sec_info = elf_section_data (sec)->sec_info;
1334 htab = elf_hash_table (info);
1335 hdr_info = &htab->eh_info;
1336
1337 if (hdr_info->table && hdr_info->array == NULL)
1338 hdr_info->array
1339 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1340 if (hdr_info->array == NULL)
1341 hdr_info = NULL;
1342
1343 /* The new offsets can be bigger or smaller than the original offsets.
1344 We therefore need to make two passes over the section: one backward
1345 pass to move entries up and one forward pass to move entries down.
1346 The two passes won't interfere with each other because entries are
1347 not reordered */
1348 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1349 if (!ent->removed && ent->new_offset > ent->offset)
1350 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1351
1352 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1353 if (!ent->removed && ent->new_offset < ent->offset)
1354 memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1355
1356 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1357 {
1358 unsigned char *buf, *end;
1359 unsigned int new_size;
1360
1361 if (ent->removed)
1362 continue;
1363
1364 if (ent->size == 4)
1365 {
1366 /* Any terminating FDE must be at the end of the section. */
1367 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1368 continue;
1369 }
1370
1371 buf = contents + ent->new_offset;
1372 end = buf + ent->size;
1373 new_size = size_of_output_cie_fde (ent, ptr_size);
1374
1375 /* Update the size. It may be shrinked. */
1376 bfd_put_32 (abfd, new_size - 4, buf);
1377
1378 /* Filling the extra bytes with DW_CFA_nops. */
1379 if (new_size != ent->size)
1380 memset (end, 0, new_size - ent->size);
1381
1382 if (ent->cie)
1383 {
1384 /* CIE */
1385 if (ent->make_relative
1386 || ent->u.cie.make_lsda_relative
1387 || ent->u.cie.per_encoding_relative)
1388 {
1389 char *aug;
1390 unsigned int action, extra_string, extra_data;
1391 unsigned int per_width, per_encoding;
1392
1393 /* Need to find 'R' or 'L' augmentation's argument and modify
1394 DW_EH_PE_* value. */
1395 action = ((ent->make_relative ? 1 : 0)
1396 | (ent->u.cie.make_lsda_relative ? 2 : 0)
1397 | (ent->u.cie.per_encoding_relative ? 4 : 0));
1398 extra_string = extra_augmentation_string_bytes (ent);
1399 extra_data = extra_augmentation_data_bytes (ent);
1400
1401 /* Skip length, id and version. */
1402 buf += 9;
1403 aug = (char *) buf;
1404 buf += strlen (aug) + 1;
1405 skip_leb128 (&buf, end);
1406 skip_leb128 (&buf, end);
1407 skip_leb128 (&buf, end);
1408 if (*aug == 'z')
1409 {
1410 /* The uleb128 will always be a single byte for the kind
1411 of augmentation strings that we're prepared to handle. */
1412 *buf++ += extra_data;
1413 aug++;
1414 }
1415
1416 /* Make room for the new augmentation string and data bytes. */
1417 memmove (buf + extra_string + extra_data, buf, end - buf);
1418 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1419 buf += extra_string;
1420 end += extra_string + extra_data;
1421
1422 if (ent->add_augmentation_size)
1423 {
1424 *aug++ = 'z';
1425 *buf++ = extra_data - 1;
1426 }
1427 if (ent->u.cie.add_fde_encoding)
1428 {
1429 BFD_ASSERT (action & 1);
1430 *aug++ = 'R';
1431 *buf++ = DW_EH_PE_pcrel;
1432 action &= ~1;
1433 }
1434
1435 while (action)
1436 switch (*aug++)
1437 {
1438 case 'L':
1439 if (action & 2)
1440 {
1441 BFD_ASSERT (*buf == ent->lsda_encoding);
1442 *buf |= DW_EH_PE_pcrel;
1443 action &= ~2;
1444 }
1445 buf++;
1446 break;
1447 case 'P':
1448 per_encoding = *buf++;
1449 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1450 BFD_ASSERT (per_width != 0);
1451 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1452 == ent->u.cie.per_encoding_relative);
1453 if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1454 buf = (contents
1455 + ((buf - contents + per_width - 1)
1456 & ~((bfd_size_type) per_width - 1)));
1457 if (action & 4)
1458 {
1459 bfd_vma val;
1460
1461 val = read_value (abfd, buf, per_width,
1462 get_DW_EH_PE_signed (per_encoding));
1463 val += (bfd_vma) ent->offset - ent->new_offset;
1464 val -= extra_string + extra_data;
1465 write_value (abfd, buf, val, per_width);
1466 action &= ~4;
1467 }
1468 buf += per_width;
1469 break;
1470 case 'R':
1471 if (action & 1)
1472 {
1473 BFD_ASSERT (*buf == ent->fde_encoding);
1474 *buf |= DW_EH_PE_pcrel;
1475 action &= ~1;
1476 }
1477 buf++;
1478 break;
1479 case 'S':
1480 break;
1481 default:
1482 BFD_FAIL ();
1483 }
1484 }
1485 }
1486 else
1487 {
1488 /* FDE */
1489 bfd_vma value, address;
1490 unsigned int width;
1491 bfd_byte *start;
1492 struct eh_cie_fde *cie;
1493
1494 /* Skip length. */
1495 cie = ent->u.fde.cie_inf;
1496 buf += 4;
1497 value = ((ent->new_offset + sec->output_offset + 4)
1498 - (cie->new_offset + cie->u.cie.u.sec->output_offset));
1499 bfd_put_32 (abfd, value, buf);
1500 buf += 4;
1501 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1502 value = read_value (abfd, buf, width,
1503 get_DW_EH_PE_signed (ent->fde_encoding));
1504 address = value;
1505 if (value)
1506 {
1507 switch (ent->fde_encoding & 0xf0)
1508 {
1509 case DW_EH_PE_indirect:
1510 case DW_EH_PE_textrel:
1511 BFD_ASSERT (hdr_info == NULL);
1512 break;
1513 case DW_EH_PE_datarel:
1514 {
1515 asection *got = bfd_get_section_by_name (abfd, ".got");
1516
1517 BFD_ASSERT (got != NULL);
1518 address += got->vma;
1519 }
1520 break;
1521 case DW_EH_PE_pcrel:
1522 value += (bfd_vma) ent->offset - ent->new_offset;
1523 address += (sec->output_section->vma
1524 + sec->output_offset
1525 + ent->offset + 8);
1526 break;
1527 }
1528 if (ent->make_relative)
1529 value -= (sec->output_section->vma
1530 + sec->output_offset
1531 + ent->new_offset + 8);
1532 write_value (abfd, buf, value, width);
1533 }
1534
1535 start = buf;
1536
1537 if (hdr_info)
1538 {
1539 hdr_info->array[hdr_info->array_count].initial_loc = address;
1540 hdr_info->array[hdr_info->array_count++].fde
1541 = (sec->output_section->vma
1542 + sec->output_offset
1543 + ent->new_offset);
1544 }
1545
1546 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1547 || cie->u.cie.make_lsda_relative)
1548 {
1549 buf += ent->lsda_offset;
1550 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1551 value = read_value (abfd, buf, width,
1552 get_DW_EH_PE_signed (ent->lsda_encoding));
1553 if (value)
1554 {
1555 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1556 value += (bfd_vma) ent->offset - ent->new_offset;
1557 else if (cie->u.cie.make_lsda_relative)
1558 value -= (sec->output_section->vma
1559 + sec->output_offset
1560 + ent->new_offset + 8 + ent->lsda_offset);
1561 write_value (abfd, buf, value, width);
1562 }
1563 }
1564 else if (ent->add_augmentation_size)
1565 {
1566 /* Skip the PC and length and insert a zero byte for the
1567 augmentation size. */
1568 buf += width * 2;
1569 memmove (buf + 1, buf, end - buf);
1570 *buf = 0;
1571 }
1572
1573 if (ent->set_loc)
1574 {
1575 /* Adjust DW_CFA_set_loc. */
1576 unsigned int cnt, width;
1577 bfd_vma new_offset;
1578
1579 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1580 new_offset = ent->new_offset + 8
1581 + extra_augmentation_string_bytes (ent)
1582 + extra_augmentation_data_bytes (ent);
1583
1584 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1585 {
1586 bfd_vma value;
1587 buf = start + ent->set_loc[cnt];
1588
1589 value = read_value (abfd, buf, width,
1590 get_DW_EH_PE_signed (ent->fde_encoding));
1591 if (!value)
1592 continue;
1593
1594 if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1595 value += (bfd_vma) ent->offset + 8 - new_offset;
1596 if (ent->make_relative)
1597 value -= (sec->output_section->vma
1598 + sec->output_offset
1599 + new_offset + ent->set_loc[cnt]);
1600 write_value (abfd, buf, value, width);
1601 }
1602 }
1603 }
1604 }
1605
1606 /* We don't align the section to its section alignment since the
1607 runtime library only expects all CIE/FDE records aligned at
1608 the pointer size. _bfd_elf_discard_section_eh_frame should
1609 have padded CIE/FDE records to multiple of pointer size with
1610 size_of_output_cie_fde. */
1611 if ((sec->size % ptr_size) != 0)
1612 abort ();
1613
1614 return bfd_set_section_contents (abfd, sec->output_section,
1615 contents, (file_ptr) sec->output_offset,
1616 sec->size);
1617}
1618
1619/* Helper function used to sort .eh_frame_hdr search table by increasing
1620 VMA of FDE initial location. */
1621
1622static int
1623vma_compare (const void *a, const void *b)
1624{
1625 const struct eh_frame_array_ent *p = a;
1626 const struct eh_frame_array_ent *q = b;
1627 if (p->initial_loc > q->initial_loc)
1628 return 1;
1629 if (p->initial_loc < q->initial_loc)
1630 return -1;
1631 return 0;
1632}
1633
1634/* Write out .eh_frame_hdr section. This must be called after
1635 _bfd_elf_write_section_eh_frame has been called on all input
1636 .eh_frame sections.
1637 .eh_frame_hdr format:
1638 ubyte version (currently 1)
1639 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1640 .eh_frame section)
1641 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1642 number (or DW_EH_PE_omit if there is no
1643 binary search table computed))
1644 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1645 or DW_EH_PE_omit if not present.
1646 DW_EH_PE_datarel is using address of
1647 .eh_frame_hdr section start as base)
1648 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1649 optionally followed by:
1650 [encoded] fde_count (total number of FDEs in .eh_frame section)
1651 fde_count x [encoded] initial_loc, fde
1652 (array of encoded pairs containing
1653 FDE initial_location field and FDE address,
1654 sorted by increasing initial_loc). */
1655
1656bfd_boolean
1657_bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1658{
1659 struct elf_link_hash_table *htab;
1660 struct eh_frame_hdr_info *hdr_info;
1661 asection *sec;
1662 bfd_byte *contents;
1663 asection *eh_frame_sec;
1664 bfd_size_type size;
1665 bfd_boolean retval;
1666 bfd_vma encoded_eh_frame;
1667
1668 htab = elf_hash_table (info);
1669 hdr_info = &htab->eh_info;
1670 sec = hdr_info->hdr_sec;
1671 if (sec == NULL)
1672 return TRUE;
1673
1674 size = EH_FRAME_HDR_SIZE;
1675 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1676 size += 4 + hdr_info->fde_count * 8;
1677 contents = bfd_malloc (size);
1678 if (contents == NULL)
1679 return FALSE;
1680
1681 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1682 if (eh_frame_sec == NULL)
1683 {
1684 free (contents);
1685 return FALSE;
1686 }
1687
1688 memset (contents, 0, EH_FRAME_HDR_SIZE);
1689 contents[0] = 1; /* Version. */
1690 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1691 (abfd, info, eh_frame_sec, 0, sec, 4,
1692 &encoded_eh_frame); /* .eh_frame offset. */
1693
1694 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1695 {
1696 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1697 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1698 }
1699 else
1700 {
1701 contents[2] = DW_EH_PE_omit;
1702 contents[3] = DW_EH_PE_omit;
1703 }
1704 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1705
1706 if (contents[2] != DW_EH_PE_omit)
1707 {
1708 unsigned int i;
1709
1710 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1711 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1712 vma_compare);
1713 for (i = 0; i < hdr_info->fde_count; i++)
1714 {
1715 bfd_put_32 (abfd,
1716 hdr_info->array[i].initial_loc
1717 - sec->output_section->vma,
1718 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1719 bfd_put_32 (abfd,
1720 hdr_info->array[i].fde - sec->output_section->vma,
1721 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1722 }
1723 }
1724
1725 retval = bfd_set_section_contents (abfd, sec->output_section,
1726 contents, (file_ptr) sec->output_offset,
1727 sec->size);
1728 free (contents);
1729 return retval;
1730}
1731
1732/* Return the width of FDE addresses. This is the default implementation. */
1733
1734unsigned int
1735_bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1736{
1737 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1738}
1739
1740/* Decide whether we can use a PC-relative encoding within the given
1741 EH frame section. This is the default implementation. */
1742
1743bfd_boolean
1744_bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1745 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1746 asection *eh_frame_section ATTRIBUTE_UNUSED)
1747{
1748 return TRUE;
1749}
1750
1751/* Select an encoding for the given address. Preference is given to
1752 PC-relative addressing modes. */
1753
1754bfd_byte
1755_bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1756 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1757 asection *osec, bfd_vma offset,
1758 asection *loc_sec, bfd_vma loc_offset,
1759 bfd_vma *encoded)
1760{
1761 *encoded = osec->vma + offset -
1762 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1763 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1764}
GDB Binutils - Deliverables
This page took 0.04932 seconds and 4 git commands to generate.