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 2 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, MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/dwarf2.h"
27
28 #define EH_FRAME_HDR_SIZE 8
29
30 struct cie
31 {
32 unsigned int length;
33 unsigned int hash;
34 unsigned char version;
35 unsigned char local_personality;
36 char augmentation[20];
37 bfd_vma code_align;
38 bfd_signed_vma data_align;
39 bfd_vma ra_column;
40 bfd_vma augmentation_size;
41 union {
42 struct elf_link_hash_entry *h;
43 bfd_vma val;
44 } personality;
45 asection *output_sec;
46 struct eh_cie_fde *cie_inf;
47 unsigned char per_encoding;
48 unsigned char lsda_encoding;
49 unsigned char fde_encoding;
50 unsigned char initial_insn_length;
51 unsigned char make_relative;
52 unsigned char make_lsda_relative;
53 unsigned char initial_instructions[50];
54 };
55
56
57
58 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
59 move onto the next byte. Return true on success. */
60
61 static inline bfd_boolean
read_byte(bfd_byte ** iter,bfd_byte * end,unsigned char * result)62 read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
63 {
64 if (*iter >= end)
65 return FALSE;
66 *result = *((*iter)++);
67 return TRUE;
68 }
69
70 /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
71 Return true it was possible to move LENGTH bytes. */
72
73 static inline bfd_boolean
skip_bytes(bfd_byte ** iter,bfd_byte * end,bfd_size_type length)74 skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
75 {
76 if ((bfd_size_type) (end - *iter) < length)
77 {
78 *iter = end;
79 return FALSE;
80 }
81 *iter += length;
82 return TRUE;
83 }
84
85 /* Move *ITER over an leb128, stopping at END. Return true if the end
86 of the leb128 was found. */
87
88 static bfd_boolean
skip_leb128(bfd_byte ** iter,bfd_byte * end)89 skip_leb128 (bfd_byte **iter, bfd_byte *end)
90 {
91 unsigned char byte;
92 do
93 if (!read_byte (iter, end, &byte))
94 return FALSE;
95 while (byte & 0x80);
96 return TRUE;
97 }
98
99 /* Like skip_leb128, but treat the leb128 as an unsigned value and
100 store it in *VALUE. */
101
102 static bfd_boolean
read_uleb128(bfd_byte ** iter,bfd_byte * end,bfd_vma * value)103 read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
104 {
105 bfd_byte *start, *p;
106
107 start = *iter;
108 if (!skip_leb128 (iter, end))
109 return FALSE;
110
111 p = *iter;
112 *value = *--p;
113 while (p > start)
114 *value = (*value << 7) | (*--p & 0x7f);
115
116 return TRUE;
117 }
118
119 /* Like read_uleb128, but for signed values. */
120
121 static bfd_boolean
read_sleb128(bfd_byte ** iter,bfd_byte * end,bfd_signed_vma * value)122 read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
123 {
124 bfd_byte *start, *p;
125
126 start = *iter;
127 if (!skip_leb128 (iter, end))
128 return FALSE;
129
130 p = *iter;
131 *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
132 while (p > start)
133 *value = (*value << 7) | (*--p & 0x7f);
134
135 return TRUE;
136 }
137
138 /* Return 0 if either encoding is variable width, or not yet known to bfd. */
139
140 static
get_DW_EH_PE_width(int encoding,int ptr_size)141 int get_DW_EH_PE_width (int encoding, int ptr_size)
142 {
143 /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
144 was added to bfd. */
145 if ((encoding & 0x60) == 0x60)
146 return 0;
147
148 switch (encoding & 7)
149 {
150 case DW_EH_PE_udata2: return 2;
151 case DW_EH_PE_udata4: return 4;
152 case DW_EH_PE_udata8: return 8;
153 case DW_EH_PE_absptr: return ptr_size;
154 default:
155 break;
156 }
157
158 return 0;
159 }
160
161 #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
162
163 /* Read a width sized value from memory. */
164
165 static bfd_vma
read_value(bfd * abfd,bfd_byte * buf,int width,int is_signed)166 read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
167 {
168 bfd_vma value;
169
170 switch (width)
171 {
172 case 2:
173 if (is_signed)
174 value = bfd_get_signed_16 (abfd, buf);
175 else
176 value = bfd_get_16 (abfd, buf);
177 break;
178 case 4:
179 if (is_signed)
180 value = bfd_get_signed_32 (abfd, buf);
181 else
182 value = bfd_get_32 (abfd, buf);
183 break;
184 case 8:
185 if (is_signed)
186 value = bfd_get_signed_64 (abfd, buf);
187 else
188 value = bfd_get_64 (abfd, buf);
189 break;
190 default:
191 BFD_FAIL ();
192 return 0;
193 }
194
195 return value;
196 }
197
198 /* Store a width sized value to memory. */
199
200 static void
write_value(bfd * abfd,bfd_byte * buf,bfd_vma value,int width)201 write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
202 {
203 switch (width)
204 {
205 case 2: bfd_put_16 (abfd, value, buf); break;
206 case 4: bfd_put_32 (abfd, value, buf); break;
207 case 8: bfd_put_64 (abfd, value, buf); break;
208 default: BFD_FAIL ();
209 }
210 }
211
212 /* Return one if C1 and C2 CIEs can be merged. */
213
214 static int
cie_eq(const void * e1,const void * e2)215 cie_eq (const void *e1, const void *e2)
216 {
217 const struct cie *c1 = e1;
218 const struct cie *c2 = e2;
219
220 if (c1->hash == c2->hash
221 && c1->length == c2->length
222 && c1->version == c2->version
223 && c1->local_personality == c2->local_personality
224 && strcmp (c1->augmentation, c2->augmentation) == 0
225 && strcmp (c1->augmentation, "eh") != 0
226 && c1->code_align == c2->code_align
227 && c1->data_align == c2->data_align
228 && c1->ra_column == c2->ra_column
229 && c1->augmentation_size == c2->augmentation_size
230 && memcmp (&c1->personality, &c2->personality,
231 sizeof (c1->personality)) == 0
232 && c1->output_sec == c2->output_sec
233 && c1->per_encoding == c2->per_encoding
234 && c1->lsda_encoding == c2->lsda_encoding
235 && c1->fde_encoding == c2->fde_encoding
236 && c1->initial_insn_length == c2->initial_insn_length
237 && memcmp (c1->initial_instructions,
238 c2->initial_instructions,
239 c1->initial_insn_length) == 0)
240 return 1;
241
242 return 0;
243 }
244
245 static hashval_t
cie_hash(const void * e)246 cie_hash (const void *e)
247 {
248 const struct cie *c = e;
249 return c->hash;
250 }
251
252 static hashval_t
cie_compute_hash(struct cie * c)253 cie_compute_hash (struct cie *c)
254 {
255 hashval_t h = 0;
256 h = iterative_hash_object (c->length, h);
257 h = iterative_hash_object (c->version, h);
258 h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
259 h = iterative_hash_object (c->code_align, h);
260 h = iterative_hash_object (c->data_align, h);
261 h = iterative_hash_object (c->ra_column, h);
262 h = iterative_hash_object (c->augmentation_size, h);
263 h = iterative_hash_object (c->personality, h);
264 h = iterative_hash_object (c->output_sec, h);
265 h = iterative_hash_object (c->per_encoding, h);
266 h = iterative_hash_object (c->lsda_encoding, h);
267 h = iterative_hash_object (c->fde_encoding, h);
268 h = iterative_hash_object (c->initial_insn_length, h);
269 h = iterative_hash (c->initial_instructions, c->initial_insn_length, h);
270 c->hash = h;
271 return h;
272 }
273
274 /* Return the number of extra bytes that we'll be inserting into
275 ENTRY's augmentation string. */
276
277 static INLINE unsigned int
extra_augmentation_string_bytes(struct eh_cie_fde * entry)278 extra_augmentation_string_bytes (struct eh_cie_fde *entry)
279 {
280 unsigned int size = 0;
281 if (entry->cie)
282 {
283 if (entry->add_augmentation_size)
284 size++;
285 if (entry->add_fde_encoding)
286 size++;
287 }
288 return size;
289 }
290
291 /* Likewise ENTRY's augmentation data. */
292
293 static INLINE unsigned int
extra_augmentation_data_bytes(struct eh_cie_fde * entry)294 extra_augmentation_data_bytes (struct eh_cie_fde *entry)
295 {
296 unsigned int size = 0;
297 if (entry->cie)
298 {
299 if (entry->add_augmentation_size)
300 size++;
301 if (entry->add_fde_encoding)
302 size++;
303 }
304 else
305 {
306 if (entry->cie_inf->add_augmentation_size)
307 size++;
308 }
309 return size;
310 }
311
312 /* Return the size that ENTRY will have in the output. ALIGNMENT is the
313 required alignment of ENTRY in bytes. */
314
315 static unsigned int
size_of_output_cie_fde(struct eh_cie_fde * entry,unsigned int alignment)316 size_of_output_cie_fde (struct eh_cie_fde *entry, unsigned int alignment)
317 {
318 if (entry->removed)
319 return 0;
320 if (entry->size == 4)
321 return 4;
322 return (entry->size
323 + extra_augmentation_string_bytes (entry)
324 + extra_augmentation_data_bytes (entry)
325 + alignment - 1) & -alignment;
326 }
327
328 /* Assume that the bytes between *ITER and END are CFA instructions.
329 Try to move *ITER past the first instruction and return true on
330 success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
331
332 static bfd_boolean
skip_cfa_op(bfd_byte ** iter,bfd_byte * end,unsigned int encoded_ptr_width)333 skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
334 {
335 bfd_byte op;
336 bfd_vma length;
337
338 if (!read_byte (iter, end, &op))
339 return FALSE;
340
341 switch (op & 0xc0 ? op & 0xc0 : op)
342 {
343 case DW_CFA_nop:
344 case DW_CFA_advance_loc:
345 case DW_CFA_restore:
346 case DW_CFA_remember_state:
347 case DW_CFA_restore_state:
348 case DW_CFA_GNU_window_save:
349 /* No arguments. */
350 return TRUE;
351
352 case DW_CFA_offset:
353 case DW_CFA_restore_extended:
354 case DW_CFA_undefined:
355 case DW_CFA_same_value:
356 case DW_CFA_def_cfa_register:
357 case DW_CFA_def_cfa_offset:
358 case DW_CFA_def_cfa_offset_sf:
359 case DW_CFA_GNU_args_size:
360 /* One leb128 argument. */
361 return skip_leb128 (iter, end);
362
363 case DW_CFA_val_offset:
364 case DW_CFA_val_offset_sf:
365 case DW_CFA_offset_extended:
366 case DW_CFA_register:
367 case DW_CFA_def_cfa:
368 case DW_CFA_offset_extended_sf:
369 case DW_CFA_GNU_negative_offset_extended:
370 case DW_CFA_def_cfa_sf:
371 /* Two leb128 arguments. */
372 return (skip_leb128 (iter, end)
373 && skip_leb128 (iter, end));
374
375 case DW_CFA_def_cfa_expression:
376 /* A variable-length argument. */
377 return (read_uleb128 (iter, end, &length)
378 && skip_bytes (iter, end, length));
379
380 case DW_CFA_expression:
381 case DW_CFA_val_expression:
382 /* A leb128 followed by a variable-length argument. */
383 return (skip_leb128 (iter, end)
384 && read_uleb128 (iter, end, &length)
385 && skip_bytes (iter, end, length));
386
387 case DW_CFA_set_loc:
388 return skip_bytes (iter, end, encoded_ptr_width);
389
390 case DW_CFA_advance_loc1:
391 return skip_bytes (iter, end, 1);
392
393 case DW_CFA_advance_loc2:
394 return skip_bytes (iter, end, 2);
395
396 case DW_CFA_advance_loc4:
397 return skip_bytes (iter, end, 4);
398
399 case DW_CFA_MIPS_advance_loc8:
400 return skip_bytes (iter, end, 8);
401
402 default:
403 return FALSE;
404 }
405 }
406
407 /* Try to interpret the bytes between BUF and END as CFA instructions.
408 If every byte makes sense, return a pointer to the first DW_CFA_nop
409 padding byte, or END if there is no padding. Return null otherwise.
410 ENCODED_PTR_WIDTH is as for skip_cfa_op. */
411
412 static bfd_byte *
skip_non_nops(bfd_byte * buf,bfd_byte * end,unsigned int encoded_ptr_width,unsigned int * set_loc_count)413 skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
414 unsigned int *set_loc_count)
415 {
416 bfd_byte *last;
417
418 last = buf;
419 while (buf < end)
420 if (*buf == DW_CFA_nop)
421 buf++;
422 else
423 {
424 if (*buf == DW_CFA_set_loc)
425 ++*set_loc_count;
426 if (!skip_cfa_op (&buf, end, encoded_ptr_width))
427 return 0;
428 last = buf;
429 }
430 return last;
431 }
432
433 /* This function is called for each input file before the .eh_frame
434 section is relocated. It discards duplicate CIEs and FDEs for discarded
435 functions. The function returns TRUE iff any entries have been
436 deleted. */
437
438 bfd_boolean
_bfd_elf_discard_section_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_boolean (* reloc_symbol_deleted_p)(bfd_vma,void *),struct elf_reloc_cookie * cookie)439 _bfd_elf_discard_section_eh_frame
440 (bfd *abfd, struct bfd_link_info *info, asection *sec,
441 bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
442 struct elf_reloc_cookie *cookie)
443 {
444 #define REQUIRE(COND) \
445 do \
446 if (!(COND)) \
447 goto free_no_table; \
448 while (0)
449
450 bfd_byte *ehbuf = NULL, *buf;
451 bfd_byte *last_fde;
452 struct eh_cie_fde *ent, *this_inf;
453 unsigned int hdr_length, hdr_id;
454 struct extended_cie
455 {
456 struct cie cie;
457 unsigned int offset;
458 unsigned int usage_count;
459 unsigned int entry;
460 } *ecies = NULL, *ecie;
461 unsigned int ecie_count = 0, ecie_alloced = 0;
462 struct cie *cie;
463 struct elf_link_hash_table *htab;
464 struct eh_frame_hdr_info *hdr_info;
465 struct eh_frame_sec_info *sec_info = NULL;
466 unsigned int offset;
467 unsigned int ptr_size;
468 unsigned int entry_alloced;
469
470 if (sec->size == 0)
471 {
472 /* This file does not contain .eh_frame information. */
473 return FALSE;
474 }
475
476 if (bfd_is_abs_section (sec->output_section))
477 {
478 /* At least one of the sections is being discarded from the
479 link, so we should just ignore them. */
480 return FALSE;
481 }
482
483 htab = elf_hash_table (info);
484 hdr_info = &htab->eh_info;
485
486 if (hdr_info->cies == NULL && !info->relocatable)
487 hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
488
489 /* Read the frame unwind information from abfd. */
490
491 REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
492
493 if (sec->size >= 4
494 && bfd_get_32 (abfd, ehbuf) == 0
495 && cookie->rel == cookie->relend)
496 {
497 /* Empty .eh_frame section. */
498 free (ehbuf);
499 return FALSE;
500 }
501
502 /* If .eh_frame section size doesn't fit into int, we cannot handle
503 it (it would need to use 64-bit .eh_frame format anyway). */
504 REQUIRE (sec->size == (unsigned int) sec->size);
505
506 ptr_size = (get_elf_backend_data (abfd)
507 ->elf_backend_eh_frame_address_size (abfd, sec));
508 REQUIRE (ptr_size != 0);
509
510 buf = ehbuf;
511 sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
512 + 99 * sizeof (struct eh_cie_fde));
513 REQUIRE (sec_info);
514
515 entry_alloced = 100;
516
517 #define ENSURE_NO_RELOCS(buf) \
518 REQUIRE (!(cookie->rel < cookie->relend \
519 && (cookie->rel->r_offset \
520 < (bfd_size_type) ((buf) - ehbuf)) \
521 && cookie->rel->r_info != 0))
522
523 #define SKIP_RELOCS(buf) \
524 while (cookie->rel < cookie->relend \
525 && (cookie->rel->r_offset \
526 < (bfd_size_type) ((buf) - ehbuf))) \
527 cookie->rel++
528
529 #define GET_RELOC(buf) \
530 ((cookie->rel < cookie->relend \
531 && (cookie->rel->r_offset \
532 == (bfd_size_type) ((buf) - ehbuf))) \
533 ? cookie->rel : NULL)
534
535 for (;;)
536 {
537 char *aug;
538 bfd_byte *start, *end, *insns, *insns_end;
539 bfd_size_type length;
540 unsigned int set_loc_count;
541
542 if (sec_info->count == entry_alloced)
543 {
544 sec_info = bfd_realloc (sec_info,
545 sizeof (struct eh_frame_sec_info)
546 + ((entry_alloced + 99)
547 * sizeof (struct eh_cie_fde)));
548 REQUIRE (sec_info);
549
550 memset (&sec_info->entry[entry_alloced], 0,
551 100 * sizeof (struct eh_cie_fde));
552 entry_alloced += 100;
553 }
554
555 this_inf = sec_info->entry + sec_info->count;
556 last_fde = buf;
557
558 if ((bfd_size_type) (buf - ehbuf) == sec->size)
559 break;
560
561 /* Read the length of the entry. */
562 REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
563 hdr_length = bfd_get_32 (abfd, buf - 4);
564
565 /* 64-bit .eh_frame is not supported. */
566 REQUIRE (hdr_length != 0xffffffff);
567
568 /* The CIE/FDE must be fully contained in this input section. */
569 REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
570 end = buf + hdr_length;
571
572 this_inf->offset = last_fde - ehbuf;
573 this_inf->size = 4 + hdr_length;
574
575 if (hdr_length == 0)
576 {
577 /* A zero-length CIE should only be found at the end of
578 the section. */
579 REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
580 ENSURE_NO_RELOCS (buf);
581 sec_info->count++;
582 break;
583 }
584
585 REQUIRE (skip_bytes (&buf, end, 4));
586 hdr_id = bfd_get_32 (abfd, buf - 4);
587
588 if (hdr_id == 0)
589 {
590 unsigned int initial_insn_length;
591
592 /* CIE */
593 this_inf->cie = 1;
594
595 if (ecie_count == ecie_alloced)
596 {
597 ecies = bfd_realloc (ecies,
598 (ecie_alloced + 20) * sizeof (*ecies));
599 REQUIRE (ecies);
600 memset (&ecies[ecie_alloced], 0, 20 * sizeof (*ecies));
601 ecie_alloced += 20;
602 }
603
604 cie = &ecies[ecie_count].cie;
605 ecies[ecie_count].offset = this_inf->offset;
606 ecies[ecie_count++].entry = sec_info->count;
607 cie->length = hdr_length;
608 start = buf;
609 REQUIRE (read_byte (&buf, end, &cie->version));
610
611 /* Cannot handle unknown versions. */
612 REQUIRE (cie->version == 1 || cie->version == 3);
613 REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
614
615 strcpy (cie->augmentation, (char *) buf);
616 buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
617 ENSURE_NO_RELOCS (buf);
618 if (buf[0] == 'e' && buf[1] == 'h')
619 {
620 /* GCC < 3.0 .eh_frame CIE */
621 /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
622 is private to each CIE, so we don't need it for anything.
623 Just skip it. */
624 REQUIRE (skip_bytes (&buf, end, ptr_size));
625 SKIP_RELOCS (buf);
626 }
627 REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
628 REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
629 if (cie->version == 1)
630 {
631 REQUIRE (buf < end);
632 cie->ra_column = *buf++;
633 }
634 else
635 REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
636 ENSURE_NO_RELOCS (buf);
637 cie->lsda_encoding = DW_EH_PE_omit;
638 cie->fde_encoding = DW_EH_PE_omit;
639 cie->per_encoding = DW_EH_PE_omit;
640 aug = cie->augmentation;
641 if (aug[0] != 'e' || aug[1] != 'h')
642 {
643 if (*aug == 'z')
644 {
645 aug++;
646 REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
647 ENSURE_NO_RELOCS (buf);
648 }
649
650 while (*aug != '\0')
651 switch (*aug++)
652 {
653 case 'L':
654 REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
655 ENSURE_NO_RELOCS (buf);
656 REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
657 break;
658 case 'R':
659 REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
660 ENSURE_NO_RELOCS (buf);
661 REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
662 break;
663 case 'S':
664 break;
665 case 'P':
666 {
667 int per_width;
668
669 REQUIRE (read_byte (&buf, end, &cie->per_encoding));
670 per_width = get_DW_EH_PE_width (cie->per_encoding,
671 ptr_size);
672 REQUIRE (per_width);
673 if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
674 {
675 length = -(buf - ehbuf) & (per_width - 1);
676 REQUIRE (skip_bytes (&buf, end, length));
677 }
678 ENSURE_NO_RELOCS (buf);
679 /* Ensure we have a reloc here. */
680 if (GET_RELOC (buf) != NULL)
681 {
682 unsigned long r_symndx;
683
684 #ifdef BFD64
685 if (ptr_size == 8)
686 r_symndx = ELF64_R_SYM (cookie->rel->r_info);
687 else
688 #endif
689 r_symndx = ELF32_R_SYM (cookie->rel->r_info);
690 if (r_symndx >= cookie->locsymcount
691 || ELF_ST_BIND (cookie->locsyms[r_symndx]
692 .st_info) != STB_LOCAL)
693 {
694 struct elf_link_hash_entry *h;
695
696 r_symndx -= cookie->extsymoff;
697 h = cookie->sym_hashes[r_symndx];
698
699 while (h->root.type == bfd_link_hash_indirect
700 || h->root.type == bfd_link_hash_warning)
701 h = (struct elf_link_hash_entry *)
702 h->root.u.i.link;
703
704 cie->personality.h = h;
705 }
706 else
707 {
708 Elf_Internal_Sym *sym;
709 asection *sym_sec;
710 bfd_vma val;
711
712 sym = &cookie->locsyms[r_symndx];
713 sym_sec = (bfd_section_from_elf_index
714 (abfd, sym->st_shndx));
715 if (sym_sec != NULL)
716 {
717 if (sym_sec->kept_section != NULL)
718 sym_sec = sym_sec->kept_section;
719 if (sym_sec->output_section != NULL)
720 {
721 val = (sym->st_value
722 + sym_sec->output_offset
723 + sym_sec->output_section->vma);
724 cie->personality.val = val;
725 cie->local_personality = 1;
726 }
727 }
728 }
729
730 /* Cope with MIPS-style composite relocations. */
731 do
732 cookie->rel++;
733 while (GET_RELOC (buf) != NULL);
734 }
735 REQUIRE (skip_bytes (&buf, end, per_width));
736 REQUIRE (cie->local_personality || cie->personality.h);
737 }
738 break;
739 default:
740 /* Unrecognized augmentation. Better bail out. */
741 goto free_no_table;
742 }
743 }
744
745 /* For shared libraries, try to get rid of as many RELATIVE relocs
746 as possible. */
747 if (info->shared
748 && (get_elf_backend_data (abfd)
749 ->elf_backend_can_make_relative_eh_frame
750 (abfd, info, sec)))
751 {
752 if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
753 cie->make_relative = 1;
754 /* If the CIE doesn't already have an 'R' entry, it's fairly
755 easy to add one, provided that there's no aligned data
756 after the augmentation string. */
757 else if (cie->fde_encoding == DW_EH_PE_omit
758 && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
759 {
760 if (*cie->augmentation == 0)
761 this_inf->add_augmentation_size = 1;
762 this_inf->add_fde_encoding = 1;
763 cie->make_relative = 1;
764 }
765 }
766
767 if (info->shared
768 && (get_elf_backend_data (abfd)
769 ->elf_backend_can_make_lsda_relative_eh_frame
770 (abfd, info, sec))
771 && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
772 cie->make_lsda_relative = 1;
773
774 /* If FDE encoding was not specified, it defaults to
775 DW_EH_absptr. */
776 if (cie->fde_encoding == DW_EH_PE_omit)
777 cie->fde_encoding = DW_EH_PE_absptr;
778
779 initial_insn_length = end - buf;
780 if (initial_insn_length <= sizeof (cie->initial_instructions))
781 {
782 cie->initial_insn_length = initial_insn_length;
783 memcpy (cie->initial_instructions, buf, initial_insn_length);
784 }
785 insns = buf;
786 buf += initial_insn_length;
787 ENSURE_NO_RELOCS (buf);
788 }
789 else
790 {
791 /* Find the corresponding CIE. */
792 unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
793 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
794 if (cie_offset == ecie->offset)
795 break;
796
797 /* Ensure this FDE references one of the CIEs in this input
798 section. */
799 REQUIRE (ecie != ecies + ecie_count);
800 cie = &ecie->cie;
801
802 ENSURE_NO_RELOCS (buf);
803 REQUIRE (GET_RELOC (buf));
804
805 if ((*reloc_symbol_deleted_p) (buf - ehbuf, cookie))
806 /* This is a FDE against a discarded section. It should
807 be deleted. */
808 this_inf->removed = 1;
809 else
810 {
811 if (info->shared
812 && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
813 && cie->make_relative == 0)
814 || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
815 {
816 /* If a shared library uses absolute pointers
817 which we cannot turn into PC relative,
818 don't create the binary search table,
819 since it is affected by runtime relocations. */
820 hdr_info->table = FALSE;
821 (*info->callbacks->einfo)
822 (_("%P: fde encoding in %B(%A) prevents .eh_frame_hdr"
823 " table being created.\n"), abfd, sec);
824 }
825 ecie->usage_count++;
826 hdr_info->fde_count++;
827 this_inf->cie_inf = (void *) (ecie - ecies);
828 }
829
830 /* Skip the initial location and address range. */
831 start = buf;
832 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
833 REQUIRE (skip_bytes (&buf, end, 2 * length));
834
835 /* Skip the augmentation size, if present. */
836 if (cie->augmentation[0] == 'z')
837 REQUIRE (read_uleb128 (&buf, end, &length));
838 else
839 length = 0;
840
841 /* Of the supported augmentation characters above, only 'L'
842 adds augmentation data to the FDE. This code would need to
843 be adjusted if any future augmentations do the same thing. */
844 if (cie->lsda_encoding != DW_EH_PE_omit)
845 {
846 this_inf->lsda_offset = buf - start;
847 /* If there's no 'z' augmentation, we don't know where the
848 CFA insns begin. Assume no padding. */
849 if (cie->augmentation[0] != 'z')
850 length = end - buf;
851 }
852
853 /* Skip over the augmentation data. */
854 REQUIRE (skip_bytes (&buf, end, length));
855 insns = buf;
856
857 buf = last_fde + 4 + hdr_length;
858 SKIP_RELOCS (buf);
859 }
860
861 /* Try to interpret the CFA instructions and find the first
862 padding nop. Shrink this_inf's size so that it doesn't
863 include the padding. */
864 length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
865 set_loc_count = 0;
866 insns_end = skip_non_nops (insns, end, length, &set_loc_count);
867 /* If we don't understand the CFA instructions, we can't know
868 what needs to be adjusted there. */
869 if (insns_end == NULL
870 /* For the time being we don't support DW_CFA_set_loc in
871 CIE instructions. */
872 || (set_loc_count && this_inf->cie))
873 goto free_no_table;
874 this_inf->size -= end - insns_end;
875 if (insns_end != end && this_inf->cie)
876 {
877 cie->initial_insn_length -= end - insns_end;
878 cie->length -= end - insns_end;
879 }
880 if (set_loc_count
881 && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
882 || cie->make_relative))
883 {
884 unsigned int cnt;
885 bfd_byte *p;
886
887 this_inf->set_loc = bfd_malloc ((set_loc_count + 1)
888 * sizeof (unsigned int));
889 REQUIRE (this_inf->set_loc);
890 this_inf->set_loc[0] = set_loc_count;
891 p = insns;
892 cnt = 0;
893 while (p < end)
894 {
895 if (*p == DW_CFA_set_loc)
896 this_inf->set_loc[++cnt] = p + 1 - start;
897 REQUIRE (skip_cfa_op (&p, end, length));
898 }
899 }
900
901 this_inf->fde_encoding = cie->fde_encoding;
902 this_inf->lsda_encoding = cie->lsda_encoding;
903 sec_info->count++;
904 }
905
906 elf_section_data (sec)->sec_info = sec_info;
907 sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
908
909 /* Look at all CIEs in this section and determine which can be
910 removed as unused, which can be merged with previous duplicate
911 CIEs and which need to be kept. */
912 for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
913 {
914 if (ecie->usage_count == 0)
915 {
916 sec_info->entry[ecie->entry].removed = 1;
917 continue;
918 }
919 ecie->cie.output_sec = sec->output_section;
920 ecie->cie.cie_inf = sec_info->entry + ecie->entry;
921 cie_compute_hash (&ecie->cie);
922 if (hdr_info->cies != NULL)
923 {
924 void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
925 ecie->cie.hash, INSERT);
926 if (loc != NULL)
927 {
928 if (*loc != HTAB_EMPTY_ENTRY)
929 {
930 sec_info->entry[ecie->entry].removed = 1;
931 ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
932 continue;
933 }
934
935 *loc = malloc (sizeof (struct cie));
936 if (*loc == NULL)
937 *loc = HTAB_DELETED_ENTRY;
938 else
939 memcpy (*loc, &ecie->cie, sizeof (struct cie));
940 }
941 }
942 ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
943 ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
944 ecie->cie.cie_inf->per_encoding_relative
945 = (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
946 }
947
948 /* Ok, now we can assign new offsets. */
949 offset = 0;
950 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
951 if (!ent->removed)
952 {
953 if (!ent->cie)
954 {
955 ecie = ecies + (unsigned long) ent->cie_inf;
956 ent->cie_inf = ecie->cie.cie_inf;
957 }
958 ent->new_offset = offset;
959 offset += size_of_output_cie_fde (ent, ptr_size);
960 }
961
962 /* Resize the sec as needed. */
963 sec->rawsize = sec->size;
964 sec->size = offset;
965
966 free (ehbuf);
967 if (ecies)
968 free (ecies);
969 return offset != sec->rawsize;
970
971 free_no_table:
972 (*info->callbacks->einfo)
973 (_("%P: error in %B(%A); no .eh_frame_hdr table will be created.\n"),
974 abfd, sec);
975 if (ehbuf)
976 free (ehbuf);
977 if (sec_info)
978 free (sec_info);
979 if (ecies)
980 free (ecies);
981 hdr_info->table = FALSE;
982 return FALSE;
983
984 #undef REQUIRE
985 }
986
987 /* This function is called for .eh_frame_hdr section after
988 _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
989 input sections. It finalizes the size of .eh_frame_hdr section. */
990
991 bfd_boolean
_bfd_elf_discard_section_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)992 _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
993 {
994 struct elf_link_hash_table *htab;
995 struct eh_frame_hdr_info *hdr_info;
996 asection *sec;
997
998 htab = elf_hash_table (info);
999 hdr_info = &htab->eh_info;
1000
1001 if (hdr_info->cies != NULL)
1002 {
1003 htab_delete (hdr_info->cies);
1004 hdr_info->cies = NULL;
1005 }
1006
1007 sec = hdr_info->hdr_sec;
1008 if (sec == NULL)
1009 return FALSE;
1010
1011 sec->size = EH_FRAME_HDR_SIZE;
1012 if (hdr_info->table)
1013 sec->size += 4 + hdr_info->fde_count * 8;
1014
1015 elf_tdata (abfd)->eh_frame_hdr = sec;
1016 return TRUE;
1017 }
1018
1019 /* This function is called from size_dynamic_sections.
1020 It needs to decide whether .eh_frame_hdr should be output or not,
1021 because when the dynamic symbol table has been sized it is too late
1022 to strip sections. */
1023
1024 bfd_boolean
_bfd_elf_maybe_strip_eh_frame_hdr(struct bfd_link_info * info)1025 _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1026 {
1027 asection *o;
1028 bfd *abfd;
1029 struct elf_link_hash_table *htab;
1030 struct eh_frame_hdr_info *hdr_info;
1031
1032 htab = elf_hash_table (info);
1033 hdr_info = &htab->eh_info;
1034 if (hdr_info->hdr_sec == NULL)
1035 return TRUE;
1036
1037 if (bfd_is_abs_section (hdr_info->hdr_sec->output_section))
1038 {
1039 hdr_info->hdr_sec = NULL;
1040 return TRUE;
1041 }
1042
1043 abfd = NULL;
1044 if (info->eh_frame_hdr)
1045 for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link_next)
1046 {
1047 /* Count only sections which have at least a single CIE or FDE.
1048 There cannot be any CIE or FDE <= 8 bytes. */
1049 o = bfd_get_section_by_name (abfd, ".eh_frame");
1050 if (o && o->size > 8 && !bfd_is_abs_section (o->output_section))
1051 break;
1052 }
1053
1054 if (abfd == NULL)
1055 {
1056 hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1057 hdr_info->hdr_sec = NULL;
1058 return TRUE;
1059 }
1060
1061 hdr_info->table = TRUE;
1062 return TRUE;
1063 }
1064
1065 /* Adjust an address in the .eh_frame section. Given OFFSET within
1066 SEC, this returns the new offset in the adjusted .eh_frame section,
1067 or -1 if the address refers to a CIE/FDE which has been removed
1068 or to offset with dynamic relocation which is no longer needed. */
1069
1070 bfd_vma
_bfd_elf_eh_frame_section_offset(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,asection * sec,bfd_vma offset)1071 _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1072 struct bfd_link_info *info,
1073 asection *sec,
1074 bfd_vma offset)
1075 {
1076 struct eh_frame_sec_info *sec_info;
1077 struct elf_link_hash_table *htab;
1078 struct eh_frame_hdr_info *hdr_info;
1079 unsigned int lo, hi, mid;
1080
1081 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1082 return offset;
1083 sec_info = elf_section_data (sec)->sec_info;
1084
1085 if (offset >= sec->rawsize)
1086 return offset - sec->rawsize + sec->size;
1087
1088 htab = elf_hash_table (info);
1089 hdr_info = &htab->eh_info;
1090 if (hdr_info->offsets_adjusted)
1091 offset += sec->output_offset;
1092
1093 lo = 0;
1094 hi = sec_info->count;
1095 mid = 0;
1096 while (lo < hi)
1097 {
1098 mid = (lo + hi) / 2;
1099 if (offset < sec_info->entry[mid].offset)
1100 hi = mid;
1101 else if (offset
1102 >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1103 lo = mid + 1;
1104 else
1105 break;
1106 }
1107
1108 BFD_ASSERT (lo < hi);
1109
1110 /* FDE or CIE was removed. */
1111 if (sec_info->entry[mid].removed)
1112 return (bfd_vma) -1;
1113
1114 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1115 relocation against FDE's initial_location field. */
1116 if (!sec_info->entry[mid].cie
1117 && sec_info->entry[mid].cie_inf->make_relative
1118 && offset == sec_info->entry[mid].offset + 8)
1119 return (bfd_vma) -2;
1120
1121 /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1122 for run-time relocation against LSDA field. */
1123 if (!sec_info->entry[mid].cie
1124 && sec_info->entry[mid].cie_inf->make_lsda_relative
1125 && (offset == (sec_info->entry[mid].offset + 8
1126 + sec_info->entry[mid].lsda_offset))
1127 && (sec_info->entry[mid].cie_inf->need_lsda_relative
1128 || !hdr_info->offsets_adjusted))
1129 {
1130 sec_info->entry[mid].cie_inf->need_lsda_relative = 1;
1131 return (bfd_vma) -2;
1132 }
1133
1134 /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1135 relocation against DW_CFA_set_loc's arguments. */
1136 if (sec_info->entry[mid].set_loc
1137 && (sec_info->entry[mid].cie
1138 ? sec_info->entry[mid].make_relative
1139 : sec_info->entry[mid].cie_inf->make_relative)
1140 && (offset >= sec_info->entry[mid].offset + 8
1141 + sec_info->entry[mid].set_loc[1]))
1142 {
1143 unsigned int cnt;
1144
1145 for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1146 if (offset == sec_info->entry[mid].offset + 8
1147 + sec_info->entry[mid].set_loc[cnt])
1148 return (bfd_vma) -2;
1149 }
1150
1151 if (hdr_info->offsets_adjusted)
1152 offset -= sec->output_offset;
1153 /* Any new augmentation bytes go before the first relocation. */
1154 return (offset + sec_info->entry[mid].new_offset
1155 - sec_info->entry[mid].offset
1156 + extra_augmentation_string_bytes (sec_info->entry + mid)
1157 + extra_augmentation_data_bytes (sec_info->entry + mid));
1158 }
1159
1160 /* Write out .eh_frame section. This is called with the relocated
1161 contents. */
1162
1163 bfd_boolean
_bfd_elf_write_section_eh_frame(bfd * abfd,struct bfd_link_info * info,asection * sec,bfd_byte * contents)1164 _bfd_elf_write_section_eh_frame (bfd *abfd,
1165 struct bfd_link_info *info,
1166 asection *sec,
1167 bfd_byte *contents)
1168 {
1169 struct eh_frame_sec_info *sec_info;
1170 struct elf_link_hash_table *htab;
1171 struct eh_frame_hdr_info *hdr_info;
1172 unsigned int ptr_size;
1173 struct eh_cie_fde *ent;
1174
1175 if (sec->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1176 return bfd_set_section_contents (abfd, sec->output_section, contents,
1177 sec->output_offset, sec->size);
1178
1179 ptr_size = (get_elf_backend_data (abfd)
1180 ->elf_backend_eh_frame_address_size (abfd, sec));
1181 BFD_ASSERT (ptr_size != 0);
1182
1183 sec_info = elf_section_data (sec)->sec_info;
1184 htab = elf_hash_table (info);
1185 hdr_info = &htab->eh_info;
1186
1187 /* First convert all offsets to output section offsets, so that a
1188 CIE offset is valid if the CIE is used by a FDE from some other
1189 section. This can happen when duplicate CIEs are deleted in
1190 _bfd_elf_discard_section_eh_frame. We do all sections here because
1191 this function might not be called on sections in the same order as
1192 _bfd_elf_discard_section_eh_frame. */
1193 if (!hdr_info->offsets_adjusted)
1194 {
1195 bfd *ibfd;
1196 asection *eh;
1197 struct eh_frame_sec_info *eh_inf;
1198
1199 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
1200 {
1201 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1202 || (ibfd->flags & DYNAMIC) != 0)
1203 continue;
1204
1205 eh = bfd_get_section_by_name (ibfd, ".eh_frame");
1206 if (eh == NULL || eh->sec_info_type != ELF_INFO_TYPE_EH_FRAME)
1207 continue;
1208
1209 eh_inf = elf_section_data (eh)->sec_info;
1210 for (ent = eh_inf->entry; ent < eh_inf->entry + eh_inf->count; ++ent)
1211 {
1212 ent->offset += eh->output_offset;
1213 ent->new_offset += eh->output_offset;
1214 }
1215 }
1216 hdr_info->offsets_adjusted = TRUE;
1217 }
1218
1219 if (hdr_info->table && hdr_info->array == NULL)
1220 hdr_info->array
1221 = bfd_malloc (hdr_info->fde_count * sizeof(*hdr_info->array));
1222 if (hdr_info->array == NULL)
1223 hdr_info = NULL;
1224
1225 /* The new offsets can be bigger or smaller than the original offsets.
1226 We therefore need to make two passes over the section: one backward
1227 pass to move entries up and one forward pass to move entries down.
1228 The two passes won't interfere with each other because entries are
1229 not reordered */
1230 for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1231 if (!ent->removed && ent->new_offset > ent->offset)
1232 memmove (contents + ent->new_offset - sec->output_offset,
1233 contents + ent->offset - sec->output_offset, ent->size);
1234
1235 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1236 if (!ent->removed && ent->new_offset < ent->offset)
1237 memmove (contents + ent->new_offset - sec->output_offset,
1238 contents + ent->offset - sec->output_offset, ent->size);
1239
1240 for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1241 {
1242 unsigned char *buf, *end;
1243 unsigned int new_size;
1244
1245 if (ent->removed)
1246 continue;
1247
1248 if (ent->size == 4)
1249 {
1250 /* Any terminating FDE must be at the end of the section. */
1251 BFD_ASSERT (ent == sec_info->entry + sec_info->count - 1);
1252 continue;
1253 }
1254
1255 buf = contents + ent->new_offset - sec->output_offset;
1256 end = buf + ent->size;
1257 new_size = size_of_output_cie_fde (ent, ptr_size);
1258
1259 /* Update the size. It may be shrinked. */
1260 bfd_put_32 (abfd, new_size - 4, buf);
1261
1262 /* Filling the extra bytes with DW_CFA_nops. */
1263 if (new_size != ent->size)
1264 memset (end, 0, new_size - ent->size);
1265
1266 if (ent->cie)
1267 {
1268 /* CIE */
1269 if (ent->make_relative
1270 || ent->need_lsda_relative
1271 || ent->per_encoding_relative)
1272 {
1273 char *aug;
1274 unsigned int action, extra_string, extra_data;
1275 unsigned int per_width, per_encoding;
1276
1277 /* Need to find 'R' or 'L' augmentation's argument and modify
1278 DW_EH_PE_* value. */
1279 action = ((ent->make_relative ? 1 : 0)
1280 | (ent->need_lsda_relative ? 2 : 0)
1281 | (ent->per_encoding_relative ? 4 : 0));
1282 extra_string = extra_augmentation_string_bytes (ent);
1283 extra_data = extra_augmentation_data_bytes (ent);
1284
1285 /* Skip length, id and version. */
1286 buf += 9;
1287 aug = (char *) buf;
1288 buf += strlen (aug) + 1;
1289 skip_leb128 (&buf, end);
1290 skip_leb128 (&buf, end);
1291 skip_leb128 (&buf, end);
1292 if (*aug == 'z')
1293 {
1294 /* The uleb128 will always be a single byte for the kind
1295 of augmentation strings that we're prepared to handle. */
1296 *buf++ += extra_data;
1297 aug++;
1298 }
1299
1300 /* Make room for the new augmentation string and data bytes. */
1301 memmove (buf + extra_string + extra_data, buf, end - buf);
1302 memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
1303 buf += extra_string;
1304 end += extra_string + extra_data;
1305
1306 if (ent->add_augmentation_size)
1307 {
1308 *aug++ = 'z';
1309 *buf++ = extra_data - 1;
1310 }
1311 if (ent->add_fde_encoding)
1312 {
1313 BFD_ASSERT (action & 1);
1314 *aug++ = 'R';
1315 *buf++ = DW_EH_PE_pcrel;
1316 action &= ~1;
1317 }
1318
1319 while (action)
1320 switch (*aug++)
1321 {
1322 case 'L':
1323 if (action & 2)
1324 {
1325 BFD_ASSERT (*buf == ent->lsda_encoding);
1326 *buf |= DW_EH_PE_pcrel;
1327 action &= ~2;
1328 }
1329 buf++;
1330 break;
1331 case 'P':
1332 per_encoding = *buf++;
1333 per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
1334 BFD_ASSERT (per_width != 0);
1335 BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
1336 == ent->per_encoding_relative);
1337 if ((per_encoding & 0xf0) == DW_EH_PE_aligned)
1338 buf = (contents
1339 + ((buf - contents + per_width - 1)
1340 & ~((bfd_size_type) per_width - 1)));
1341 if (action & 4)
1342 {
1343 bfd_vma val;
1344
1345 val = read_value (abfd, buf, per_width,
1346 get_DW_EH_PE_signed (per_encoding));
1347 val += ent->offset - ent->new_offset;
1348 val -= extra_string + extra_data;
1349 write_value (abfd, buf, val, per_width);
1350 action &= ~4;
1351 }
1352 buf += per_width;
1353 break;
1354 case 'R':
1355 if (action & 1)
1356 {
1357 BFD_ASSERT (*buf == ent->fde_encoding);
1358 *buf |= DW_EH_PE_pcrel;
1359 action &= ~1;
1360 }
1361 buf++;
1362 break;
1363 case 'S':
1364 break;
1365 default:
1366 BFD_FAIL ();
1367 }
1368 }
1369 }
1370 else
1371 {
1372 /* FDE */
1373 bfd_vma value, address;
1374 unsigned int width;
1375 bfd_byte *start;
1376
1377 /* Skip length. */
1378 buf += 4;
1379 value = ent->new_offset + 4 - ent->cie_inf->new_offset;
1380 bfd_put_32 (abfd, value, buf);
1381 buf += 4;
1382 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1383 value = read_value (abfd, buf, width,
1384 get_DW_EH_PE_signed (ent->fde_encoding));
1385 address = value;
1386 if (value)
1387 {
1388 switch (ent->fde_encoding & 0xf0)
1389 {
1390 case DW_EH_PE_indirect:
1391 case DW_EH_PE_textrel:
1392 BFD_ASSERT (hdr_info == NULL);
1393 break;
1394 case DW_EH_PE_datarel:
1395 {
1396 asection *got = bfd_get_section_by_name (abfd, ".got");
1397
1398 BFD_ASSERT (got != NULL);
1399 address += got->vma;
1400 }
1401 break;
1402 case DW_EH_PE_pcrel:
1403 value += ent->offset - ent->new_offset;
1404 address += sec->output_section->vma + ent->offset + 8;
1405 break;
1406 }
1407 if (ent->cie_inf->make_relative)
1408 value -= sec->output_section->vma + ent->new_offset + 8;
1409 write_value (abfd, buf, value, width);
1410 }
1411
1412 start = buf;
1413
1414 if (hdr_info)
1415 {
1416 hdr_info->array[hdr_info->array_count].initial_loc = address;
1417 hdr_info->array[hdr_info->array_count++].fde
1418 = sec->output_section->vma + ent->new_offset;
1419 }
1420
1421 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel
1422 || ent->cie_inf->need_lsda_relative)
1423 {
1424 buf += ent->lsda_offset;
1425 width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
1426 value = read_value (abfd, buf, width,
1427 get_DW_EH_PE_signed (ent->lsda_encoding));
1428 if (value)
1429 {
1430 if ((ent->lsda_encoding & 0xf0) == DW_EH_PE_pcrel)
1431 value += ent->offset - ent->new_offset;
1432 else if (ent->cie_inf->need_lsda_relative)
1433 value -= (sec->output_section->vma + ent->new_offset + 8
1434 + ent->lsda_offset);
1435 write_value (abfd, buf, value, width);
1436 }
1437 }
1438 else if (ent->cie_inf->add_augmentation_size)
1439 {
1440 /* Skip the PC and length and insert a zero byte for the
1441 augmentation size. */
1442 buf += width * 2;
1443 memmove (buf + 1, buf, end - buf);
1444 *buf = 0;
1445 }
1446
1447 if (ent->set_loc)
1448 {
1449 /* Adjust DW_CFA_set_loc. */
1450 unsigned int cnt, width;
1451 bfd_vma new_offset;
1452
1453 width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1454 new_offset = ent->new_offset + 8
1455 + extra_augmentation_string_bytes (ent)
1456 + extra_augmentation_data_bytes (ent);
1457
1458 for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
1459 {
1460 bfd_vma value;
1461 buf = start + ent->set_loc[cnt];
1462
1463 value = read_value (abfd, buf, width,
1464 get_DW_EH_PE_signed (ent->fde_encoding));
1465 if (!value)
1466 continue;
1467
1468 if ((ent->fde_encoding & 0xf0) == DW_EH_PE_pcrel)
1469 value += ent->offset + 8 - new_offset;
1470 if (ent->cie_inf->make_relative)
1471 value -= sec->output_section->vma + new_offset
1472 + ent->set_loc[cnt];
1473 write_value (abfd, buf, value, width);
1474 }
1475 }
1476 }
1477 }
1478
1479 /* We don't align the section to its section alignment since the
1480 runtime library only expects all CIE/FDE records aligned at
1481 the pointer size. _bfd_elf_discard_section_eh_frame should
1482 have padded CIE/FDE records to multiple of pointer size with
1483 size_of_output_cie_fde. */
1484 if ((sec->size % ptr_size) != 0)
1485 abort ();
1486
1487 return bfd_set_section_contents (abfd, sec->output_section,
1488 contents, (file_ptr) sec->output_offset,
1489 sec->size);
1490 }
1491
1492 /* Helper function used to sort .eh_frame_hdr search table by increasing
1493 VMA of FDE initial location. */
1494
1495 static int
vma_compare(const void * a,const void * b)1496 vma_compare (const void *a, const void *b)
1497 {
1498 const struct eh_frame_array_ent *p = a;
1499 const struct eh_frame_array_ent *q = b;
1500 if (p->initial_loc > q->initial_loc)
1501 return 1;
1502 if (p->initial_loc < q->initial_loc)
1503 return -1;
1504 return 0;
1505 }
1506
1507 /* Write out .eh_frame_hdr section. This must be called after
1508 _bfd_elf_write_section_eh_frame has been called on all input
1509 .eh_frame sections.
1510 .eh_frame_hdr format:
1511 ubyte version (currently 1)
1512 ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1513 .eh_frame section)
1514 ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
1515 number (or DW_EH_PE_omit if there is no
1516 binary search table computed))
1517 ubyte table_enc (DW_EH_PE_* encoding of binary search table,
1518 or DW_EH_PE_omit if not present.
1519 DW_EH_PE_datarel is using address of
1520 .eh_frame_hdr section start as base)
1521 [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
1522 optionally followed by:
1523 [encoded] fde_count (total number of FDEs in .eh_frame section)
1524 fde_count x [encoded] initial_loc, fde
1525 (array of encoded pairs containing
1526 FDE initial_location field and FDE address,
1527 sorted by increasing initial_loc). */
1528
1529 bfd_boolean
_bfd_elf_write_section_eh_frame_hdr(bfd * abfd,struct bfd_link_info * info)1530 _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1531 {
1532 struct elf_link_hash_table *htab;
1533 struct eh_frame_hdr_info *hdr_info;
1534 asection *sec;
1535 bfd_byte *contents;
1536 asection *eh_frame_sec;
1537 bfd_size_type size;
1538 bfd_boolean retval;
1539 bfd_vma encoded_eh_frame;
1540
1541 htab = elf_hash_table (info);
1542 hdr_info = &htab->eh_info;
1543 sec = hdr_info->hdr_sec;
1544 if (sec == NULL)
1545 return TRUE;
1546
1547 size = EH_FRAME_HDR_SIZE;
1548 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1549 size += 4 + hdr_info->fde_count * 8;
1550 contents = bfd_malloc (size);
1551 if (contents == NULL)
1552 return FALSE;
1553
1554 eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
1555 if (eh_frame_sec == NULL)
1556 {
1557 free (contents);
1558 return FALSE;
1559 }
1560
1561 memset (contents, 0, EH_FRAME_HDR_SIZE);
1562 contents[0] = 1; /* Version. */
1563 contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1564 (abfd, info, eh_frame_sec, 0, sec, 4,
1565 &encoded_eh_frame); /* .eh_frame offset. */
1566
1567 if (hdr_info->array && hdr_info->array_count == hdr_info->fde_count)
1568 {
1569 contents[2] = DW_EH_PE_udata4; /* FDE count encoding. */
1570 contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4; /* Search table enc. */
1571 }
1572 else
1573 {
1574 contents[2] = DW_EH_PE_omit;
1575 contents[3] = DW_EH_PE_omit;
1576 }
1577 bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
1578
1579 if (contents[2] != DW_EH_PE_omit)
1580 {
1581 unsigned int i;
1582
1583 bfd_put_32 (abfd, hdr_info->fde_count, contents + EH_FRAME_HDR_SIZE);
1584 qsort (hdr_info->array, hdr_info->fde_count, sizeof (*hdr_info->array),
1585 vma_compare);
1586 for (i = 0; i < hdr_info->fde_count; i++)
1587 {
1588 bfd_put_32 (abfd,
1589 hdr_info->array[i].initial_loc
1590 - sec->output_section->vma,
1591 contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
1592 bfd_put_32 (abfd,
1593 hdr_info->array[i].fde - sec->output_section->vma,
1594 contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
1595 }
1596 }
1597
1598 retval = bfd_set_section_contents (abfd, sec->output_section,
1599 contents, (file_ptr) sec->output_offset,
1600 sec->size);
1601 free (contents);
1602 return retval;
1603 }
1604
1605 /* Return the width of FDE addresses. This is the default implementation. */
1606
1607 unsigned int
_bfd_elf_eh_frame_address_size(bfd * abfd,asection * sec ATTRIBUTE_UNUSED)1608 _bfd_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1609 {
1610 return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
1611 }
1612
1613 /* Decide whether we can use a PC-relative encoding within the given
1614 EH frame section. This is the default implementation. */
1615
1616 bfd_boolean
_bfd_elf_can_make_relative(bfd * input_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * eh_frame_section ATTRIBUTE_UNUSED)1617 _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
1618 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1619 asection *eh_frame_section ATTRIBUTE_UNUSED)
1620 {
1621 return TRUE;
1622 }
1623
1624 /* Select an encoding for the given address. Preference is given to
1625 PC-relative addressing modes. */
1626
1627 bfd_byte
_bfd_elf_encode_eh_address(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * osec,bfd_vma offset,asection * loc_sec,bfd_vma loc_offset,bfd_vma * encoded)1628 _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
1629 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1630 asection *osec, bfd_vma offset,
1631 asection *loc_sec, bfd_vma loc_offset,
1632 bfd_vma *encoded)
1633 {
1634 *encoded = osec->vma + offset -
1635 (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
1636 return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
1637 }
1638