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