Annotation of src/external/gpl3/binutils.old/dist/bfd/elf-eh-frame.c, Revision 1.7
1.1 christos 1: /* .eh_frame section optimization.
1.7 ! christos 2: Copyright (C) 2001-2020 Free Software Foundation, Inc.
1.1 christos 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 3 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,
20: MA 02110-1301, USA. */
21:
22: #include "sysdep.h"
23: #include "bfd.h"
24: #include "libbfd.h"
25: #include "elf-bfd.h"
26: #include "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;
1.3 christos 43: struct {
44: unsigned int bfd_id;
45: unsigned int index;
46: } sym;
1.1 christos 47: unsigned int reloc_index;
48: } personality;
49: struct eh_cie_fde *cie_inf;
50: unsigned char per_encoding;
51: unsigned char lsda_encoding;
52: unsigned char fde_encoding;
53: unsigned char initial_insn_length;
54: unsigned char can_make_lsda_relative;
55: unsigned char initial_instructions[50];
56: };
57:
58:
59:
60: /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
61: move onto the next byte. Return true on success. */
62:
63: static inline bfd_boolean
64: read_byte (bfd_byte **iter, bfd_byte *end, unsigned char *result)
65: {
66: if (*iter >= end)
67: return FALSE;
68: *result = *((*iter)++);
69: return TRUE;
70: }
71:
72: /* Move *ITER over LENGTH bytes, or up to END, whichever is closer.
73: Return true it was possible to move LENGTH bytes. */
74:
75: static inline bfd_boolean
76: skip_bytes (bfd_byte **iter, bfd_byte *end, bfd_size_type length)
77: {
78: if ((bfd_size_type) (end - *iter) < length)
79: {
80: *iter = end;
81: return FALSE;
82: }
83: *iter += length;
84: return TRUE;
85: }
86:
87: /* Move *ITER over an leb128, stopping at END. Return true if the end
88: of the leb128 was found. */
89:
90: static bfd_boolean
91: skip_leb128 (bfd_byte **iter, bfd_byte *end)
92: {
93: unsigned char byte;
94: do
95: if (!read_byte (iter, end, &byte))
96: return FALSE;
97: while (byte & 0x80);
98: return TRUE;
99: }
100:
101: /* Like skip_leb128, but treat the leb128 as an unsigned value and
102: store it in *VALUE. */
103:
104: static bfd_boolean
105: read_uleb128 (bfd_byte **iter, bfd_byte *end, bfd_vma *value)
106: {
107: bfd_byte *start, *p;
108:
109: start = *iter;
110: if (!skip_leb128 (iter, end))
111: return FALSE;
112:
113: p = *iter;
114: *value = *--p;
115: while (p > start)
116: *value = (*value << 7) | (*--p & 0x7f);
117:
118: return TRUE;
119: }
120:
121: /* Like read_uleb128, but for signed values. */
122:
123: static bfd_boolean
124: read_sleb128 (bfd_byte **iter, bfd_byte *end, bfd_signed_vma *value)
125: {
126: bfd_byte *start, *p;
127:
128: start = *iter;
129: if (!skip_leb128 (iter, end))
130: return FALSE;
131:
132: p = *iter;
133: *value = ((*--p & 0x7f) ^ 0x40) - 0x40;
134: while (p > start)
135: *value = (*value << 7) | (*--p & 0x7f);
136:
137: return TRUE;
138: }
139:
140: /* Return 0 if either encoding is variable width, or not yet known to bfd. */
141:
142: static
143: int get_DW_EH_PE_width (int encoding, int ptr_size)
144: {
145: /* DW_EH_PE_ values of 0x60 and 0x70 weren't defined at the time .eh_frame
146: was added to bfd. */
147: if ((encoding & 0x60) == 0x60)
148: return 0;
149:
150: switch (encoding & 7)
151: {
152: case DW_EH_PE_udata2: return 2;
153: case DW_EH_PE_udata4: return 4;
154: case DW_EH_PE_udata8: return 8;
155: case DW_EH_PE_absptr: return ptr_size;
156: default:
157: break;
158: }
159:
160: return 0;
161: }
162:
163: #define get_DW_EH_PE_signed(encoding) (((encoding) & DW_EH_PE_signed) != 0)
164:
165: /* Read a width sized value from memory. */
166:
167: static bfd_vma
168: read_value (bfd *abfd, bfd_byte *buf, int width, int is_signed)
169: {
170: bfd_vma value;
171:
172: switch (width)
173: {
174: case 2:
175: if (is_signed)
176: value = bfd_get_signed_16 (abfd, buf);
177: else
178: value = bfd_get_16 (abfd, buf);
179: break;
180: case 4:
181: if (is_signed)
182: value = bfd_get_signed_32 (abfd, buf);
183: else
184: value = bfd_get_32 (abfd, buf);
185: break;
186: case 8:
187: if (is_signed)
188: value = bfd_get_signed_64 (abfd, buf);
189: else
190: value = bfd_get_64 (abfd, buf);
191: break;
192: default:
193: BFD_FAIL ();
194: return 0;
195: }
196:
197: return value;
198: }
199:
200: /* Store a width sized value to memory. */
201:
202: static void
203: write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
204: {
205: switch (width)
206: {
207: case 2: bfd_put_16 (abfd, value, buf); break;
208: case 4: bfd_put_32 (abfd, value, buf); break;
209: case 8: bfd_put_64 (abfd, value, buf); break;
210: default: BFD_FAIL ();
211: }
212: }
213:
214: /* Return one if C1 and C2 CIEs can be merged. */
215:
216: static int
217: cie_eq (const void *e1, const void *e2)
218: {
219: const struct cie *c1 = (const struct cie *) e1;
220: const struct cie *c2 = (const struct cie *) e2;
221:
222: if (c1->hash == c2->hash
223: && c1->length == c2->length
224: && c1->version == c2->version
225: && c1->local_personality == c2->local_personality
226: && strcmp (c1->augmentation, c2->augmentation) == 0
227: && strcmp (c1->augmentation, "eh") != 0
228: && c1->code_align == c2->code_align
229: && c1->data_align == c2->data_align
230: && c1->ra_column == c2->ra_column
231: && c1->augmentation_size == c2->augmentation_size
232: && memcmp (&c1->personality, &c2->personality,
233: sizeof (c1->personality)) == 0
1.3 christos 234: && (c1->cie_inf->u.cie.u.sec->output_section
235: == c2->cie_inf->u.cie.u.sec->output_section)
1.1 christos 236: && c1->per_encoding == c2->per_encoding
237: && c1->lsda_encoding == c2->lsda_encoding
238: && c1->fde_encoding == c2->fde_encoding
239: && c1->initial_insn_length == c2->initial_insn_length
1.3 christos 240: && c1->initial_insn_length <= sizeof (c1->initial_instructions)
1.1 christos 241: && memcmp (c1->initial_instructions,
242: c2->initial_instructions,
243: c1->initial_insn_length) == 0)
244: return 1;
245:
246: return 0;
247: }
248:
249: static hashval_t
250: cie_hash (const void *e)
251: {
252: const struct cie *c = (const struct cie *) e;
253: return c->hash;
254: }
255:
256: static hashval_t
257: cie_compute_hash (struct cie *c)
258: {
259: hashval_t h = 0;
1.3 christos 260: size_t len;
1.1 christos 261: h = iterative_hash_object (c->length, h);
262: h = iterative_hash_object (c->version, h);
263: h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
264: h = iterative_hash_object (c->code_align, h);
265: h = iterative_hash_object (c->data_align, h);
266: h = iterative_hash_object (c->ra_column, h);
267: h = iterative_hash_object (c->augmentation_size, h);
268: h = iterative_hash_object (c->personality, h);
1.3 christos 269: h = iterative_hash_object (c->cie_inf->u.cie.u.sec->output_section, h);
1.1 christos 270: h = iterative_hash_object (c->per_encoding, h);
271: h = iterative_hash_object (c->lsda_encoding, h);
272: h = iterative_hash_object (c->fde_encoding, h);
273: h = iterative_hash_object (c->initial_insn_length, h);
1.3 christos 274: len = c->initial_insn_length;
275: if (len > sizeof (c->initial_instructions))
276: len = sizeof (c->initial_instructions);
277: h = iterative_hash (c->initial_instructions, len, h);
1.1 christos 278: c->hash = h;
279: return h;
280: }
281:
282: /* Return the number of extra bytes that we'll be inserting into
283: ENTRY's augmentation string. */
284:
285: static INLINE unsigned int
286: extra_augmentation_string_bytes (struct eh_cie_fde *entry)
287: {
288: unsigned int size = 0;
289: if (entry->cie)
290: {
291: if (entry->add_augmentation_size)
292: size++;
293: if (entry->u.cie.add_fde_encoding)
294: size++;
295: }
296: return size;
297: }
298:
299: /* Likewise ENTRY's augmentation data. */
300:
301: static INLINE unsigned int
302: extra_augmentation_data_bytes (struct eh_cie_fde *entry)
303: {
304: unsigned int size = 0;
305: if (entry->add_augmentation_size)
306: size++;
307: if (entry->cie && entry->u.cie.add_fde_encoding)
308: size++;
309: return size;
310: }
311:
1.6 christos 312: /* Return the size that ENTRY will have in the output. */
1.1 christos 313:
314: static unsigned int
1.6 christos 315: size_of_output_cie_fde (struct eh_cie_fde *entry)
1.1 christos 316: {
317: if (entry->removed)
318: return 0;
319: if (entry->size == 4)
320: return 4;
321: return (entry->size
322: + extra_augmentation_string_bytes (entry)
1.6 christos 323: + extra_augmentation_data_bytes (entry));
324: }
325:
326: /* Return the offset of the FDE or CIE after ENT. */
327:
328: static unsigned int
329: next_cie_fde_offset (const struct eh_cie_fde *ent,
330: const struct eh_cie_fde *last,
331: const asection *sec)
332: {
333: while (++ent < last)
334: {
335: if (!ent->removed)
336: return ent->new_offset;
337: }
338: return sec->size;
1.1 christos 339: }
340:
341: /* Assume that the bytes between *ITER and END are CFA instructions.
342: Try to move *ITER past the first instruction and return true on
343: success. ENCODED_PTR_WIDTH gives the width of pointer entries. */
344:
345: static bfd_boolean
346: skip_cfa_op (bfd_byte **iter, bfd_byte *end, unsigned int encoded_ptr_width)
347: {
348: bfd_byte op;
349: bfd_vma length;
350:
351: if (!read_byte (iter, end, &op))
352: return FALSE;
353:
354: switch (op & 0xc0 ? op & 0xc0 : op)
355: {
356: case DW_CFA_nop:
357: case DW_CFA_advance_loc:
358: case DW_CFA_restore:
359: case DW_CFA_remember_state:
360: case DW_CFA_restore_state:
361: case DW_CFA_GNU_window_save:
362: /* No arguments. */
363: return TRUE;
364:
365: case DW_CFA_offset:
366: case DW_CFA_restore_extended:
367: case DW_CFA_undefined:
368: case DW_CFA_same_value:
369: case DW_CFA_def_cfa_register:
370: case DW_CFA_def_cfa_offset:
371: case DW_CFA_def_cfa_offset_sf:
372: case DW_CFA_GNU_args_size:
373: /* One leb128 argument. */
374: return skip_leb128 (iter, end);
375:
376: case DW_CFA_val_offset:
377: case DW_CFA_val_offset_sf:
378: case DW_CFA_offset_extended:
379: case DW_CFA_register:
380: case DW_CFA_def_cfa:
381: case DW_CFA_offset_extended_sf:
382: case DW_CFA_GNU_negative_offset_extended:
383: case DW_CFA_def_cfa_sf:
384: /* Two leb128 arguments. */
385: return (skip_leb128 (iter, end)
386: && skip_leb128 (iter, end));
387:
388: case DW_CFA_def_cfa_expression:
389: /* A variable-length argument. */
390: return (read_uleb128 (iter, end, &length)
391: && skip_bytes (iter, end, length));
392:
393: case DW_CFA_expression:
394: case DW_CFA_val_expression:
395: /* A leb128 followed by a variable-length argument. */
396: return (skip_leb128 (iter, end)
397: && read_uleb128 (iter, end, &length)
398: && skip_bytes (iter, end, length));
399:
400: case DW_CFA_set_loc:
401: return skip_bytes (iter, end, encoded_ptr_width);
402:
403: case DW_CFA_advance_loc1:
404: return skip_bytes (iter, end, 1);
405:
406: case DW_CFA_advance_loc2:
407: return skip_bytes (iter, end, 2);
408:
409: case DW_CFA_advance_loc4:
410: return skip_bytes (iter, end, 4);
411:
412: case DW_CFA_MIPS_advance_loc8:
413: return skip_bytes (iter, end, 8);
414:
415: default:
416: return FALSE;
417: }
418: }
419:
420: /* Try to interpret the bytes between BUF and END as CFA instructions.
421: If every byte makes sense, return a pointer to the first DW_CFA_nop
422: padding byte, or END if there is no padding. Return null otherwise.
423: ENCODED_PTR_WIDTH is as for skip_cfa_op. */
424:
425: static bfd_byte *
426: skip_non_nops (bfd_byte *buf, bfd_byte *end, unsigned int encoded_ptr_width,
427: unsigned int *set_loc_count)
428: {
429: bfd_byte *last;
430:
431: last = buf;
432: while (buf < end)
433: if (*buf == DW_CFA_nop)
434: buf++;
435: else
436: {
437: if (*buf == DW_CFA_set_loc)
438: ++*set_loc_count;
439: if (!skip_cfa_op (&buf, end, encoded_ptr_width))
440: return 0;
441: last = buf;
442: }
443: return last;
444: }
445:
446: /* Convert absolute encoding ENCODING into PC-relative form.
447: SIZE is the size of a pointer. */
448:
449: static unsigned char
450: make_pc_relative (unsigned char encoding, unsigned int ptr_size)
451: {
452: if ((encoding & 0x7f) == DW_EH_PE_absptr)
453: switch (ptr_size)
454: {
455: case 2:
456: encoding |= DW_EH_PE_sdata2;
457: break;
458: case 4:
459: encoding |= DW_EH_PE_sdata4;
460: break;
461: case 8:
462: encoding |= DW_EH_PE_sdata8;
463: break;
464: }
465: return encoding | DW_EH_PE_pcrel;
466: }
467:
1.3 christos 468: /* Examine each .eh_frame_entry section and discard those
469: those that are marked SEC_EXCLUDE. */
1.1 christos 470:
1.3 christos 471: static void
472: bfd_elf_discard_eh_frame_entry (struct eh_frame_hdr_info *hdr_info)
473: {
474: unsigned int i;
475: for (i = 0; i < hdr_info->array_count; i++)
476: {
477: if (hdr_info->u.compact.entries[i]->flags & SEC_EXCLUDE)
478: {
479: unsigned int j;
480: for (j = i + 1; j < hdr_info->array_count; j++)
481: hdr_info->u.compact.entries[j-1] = hdr_info->u.compact.entries[j];
482:
483: hdr_info->array_count--;
484: hdr_info->u.compact.entries[hdr_info->array_count] = NULL;
485: i--;
1.6 christos 486: }
1.3 christos 487: }
488: }
489:
490: /* Add a .eh_frame_entry section. */
491:
492: static void
493: bfd_elf_record_eh_frame_entry (struct eh_frame_hdr_info *hdr_info,
494: asection *sec)
495: {
496: if (hdr_info->array_count == hdr_info->u.compact.allocated_entries)
497: {
498: if (hdr_info->u.compact.allocated_entries == 0)
499: {
500: hdr_info->frame_hdr_is_compact = TRUE;
501: hdr_info->u.compact.allocated_entries = 2;
502: hdr_info->u.compact.entries =
503: bfd_malloc (hdr_info->u.compact.allocated_entries
504: * sizeof (hdr_info->u.compact.entries[0]));
505: }
506: else
507: {
508: hdr_info->u.compact.allocated_entries *= 2;
509: hdr_info->u.compact.entries =
510: bfd_realloc (hdr_info->u.compact.entries,
511: hdr_info->u.compact.allocated_entries
512: * sizeof (hdr_info->u.compact.entries[0]));
513: }
514:
515: BFD_ASSERT (hdr_info->u.compact.entries);
516: }
517:
518: hdr_info->u.compact.entries[hdr_info->array_count++] = sec;
519: }
520:
521: /* Parse a .eh_frame_entry section. Figure out which text section it
522: references. */
523:
524: bfd_boolean
525: _bfd_elf_parse_eh_frame_entry (struct bfd_link_info *info,
526: asection *sec, struct elf_reloc_cookie *cookie)
1.1 christos 527: {
1.3 christos 528: struct elf_link_hash_table *htab;
1.1 christos 529: struct eh_frame_hdr_info *hdr_info;
1.3 christos 530: unsigned long r_symndx;
531: asection *text_sec;
532:
533: htab = elf_hash_table (info);
534: hdr_info = &htab->eh_info;
535:
536: if (sec->size == 0
537: || sec->sec_info_type != SEC_INFO_TYPE_NONE)
538: {
539: return TRUE;
540: }
541:
542: if (sec->output_section && bfd_is_abs_section (sec->output_section))
543: {
544: /* At least one of the sections is being discarded from the
545: link, so we should just ignore them. */
546: return TRUE;
547: }
1.1 christos 548:
1.3 christos 549: if (cookie->rel == cookie->relend)
550: return FALSE;
551:
552: /* The first relocation is the function start. */
553: r_symndx = cookie->rel->r_info >> cookie->r_sym_shift;
554: if (r_symndx == STN_UNDEF)
555: return FALSE;
556:
557: text_sec = _bfd_elf_section_for_symbol (cookie, r_symndx, FALSE);
558:
559: if (text_sec == NULL)
560: return FALSE;
561:
562: elf_section_eh_frame_entry (text_sec) = sec;
563: if (text_sec->output_section
564: && bfd_is_abs_section (text_sec->output_section))
565: sec->flags |= SEC_EXCLUDE;
566:
567: sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME_ENTRY;
568: elf_section_data (sec)->sec_info = text_sec;
569: bfd_elf_record_eh_frame_entry (hdr_info, sec);
570: return TRUE;
1.1 christos 571: }
572:
573: /* Try to parse .eh_frame section SEC, which belongs to ABFD. Store the
574: information in the section's sec_info field on success. COOKIE
575: describes the relocations in SEC. */
576:
577: void
578: _bfd_elf_parse_eh_frame (bfd *abfd, struct bfd_link_info *info,
579: asection *sec, struct elf_reloc_cookie *cookie)
580: {
581: #define REQUIRE(COND) \
582: do \
583: if (!(COND)) \
584: goto free_no_table; \
585: while (0)
586:
587: bfd_byte *ehbuf = NULL, *buf, *end;
588: bfd_byte *last_fde;
589: struct eh_cie_fde *this_inf;
590: unsigned int hdr_length, hdr_id;
591: unsigned int cie_count;
592: struct cie *cie, *local_cies = NULL;
593: struct elf_link_hash_table *htab;
594: struct eh_frame_hdr_info *hdr_info;
595: struct eh_frame_sec_info *sec_info = NULL;
596: unsigned int ptr_size;
597: unsigned int num_cies;
598: unsigned int num_entries;
599: elf_gc_mark_hook_fn gc_mark_hook;
600:
601: htab = elf_hash_table (info);
602: hdr_info = &htab->eh_info;
603:
604: if (sec->size == 0
605: || sec->sec_info_type != SEC_INFO_TYPE_NONE)
606: {
607: /* This file does not contain .eh_frame information. */
608: return;
609: }
610:
611: if (bfd_is_abs_section (sec->output_section))
612: {
613: /* At least one of the sections is being discarded from the
614: link, so we should just ignore them. */
615: return;
616: }
617:
618: /* Read the frame unwind information from abfd. */
619:
620: REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
621:
622: /* If .eh_frame section size doesn't fit into int, we cannot handle
623: it (it would need to use 64-bit .eh_frame format anyway). */
624: REQUIRE (sec->size == (unsigned int) sec->size);
625:
626: ptr_size = (get_elf_backend_data (abfd)
627: ->elf_backend_eh_frame_address_size (abfd, sec));
628: REQUIRE (ptr_size != 0);
629:
630: /* Go through the section contents and work out how many FDEs and
631: CIEs there are. */
632: buf = ehbuf;
633: end = ehbuf + sec->size;
634: num_cies = 0;
635: num_entries = 0;
636: while (buf != end)
637: {
638: num_entries++;
639:
640: /* Read the length of the entry. */
641: REQUIRE (skip_bytes (&buf, end, 4));
642: hdr_length = bfd_get_32 (abfd, buf - 4);
643:
644: /* 64-bit .eh_frame is not supported. */
645: REQUIRE (hdr_length != 0xffffffff);
646: if (hdr_length == 0)
647: break;
648:
649: REQUIRE (skip_bytes (&buf, end, 4));
650: hdr_id = bfd_get_32 (abfd, buf - 4);
651: if (hdr_id == 0)
652: num_cies++;
653:
654: REQUIRE (skip_bytes (&buf, end, hdr_length - 4));
655: }
656:
657: sec_info = (struct eh_frame_sec_info *)
658: bfd_zmalloc (sizeof (struct eh_frame_sec_info)
1.6 christos 659: + (num_entries - 1) * sizeof (struct eh_cie_fde));
1.1 christos 660: REQUIRE (sec_info);
661:
662: /* We need to have a "struct cie" for each CIE in this section. */
1.6 christos 663: if (num_cies)
664: {
665: local_cies = (struct cie *) bfd_zmalloc (num_cies * sizeof (*local_cies));
666: REQUIRE (local_cies);
667: }
1.1 christos 668:
669: /* FIXME: octets_per_byte. */
670: #define ENSURE_NO_RELOCS(buf) \
1.3 christos 671: while (cookie->rel < cookie->relend \
672: && (cookie->rel->r_offset \
673: < (bfd_size_type) ((buf) - ehbuf))) \
674: { \
675: REQUIRE (cookie->rel->r_info == 0); \
676: cookie->rel++; \
677: }
1.1 christos 678:
679: /* FIXME: octets_per_byte. */
680: #define SKIP_RELOCS(buf) \
681: while (cookie->rel < cookie->relend \
682: && (cookie->rel->r_offset \
683: < (bfd_size_type) ((buf) - ehbuf))) \
684: cookie->rel++
685:
686: /* FIXME: octets_per_byte. */
687: #define GET_RELOC(buf) \
688: ((cookie->rel < cookie->relend \
689: && (cookie->rel->r_offset \
690: == (bfd_size_type) ((buf) - ehbuf))) \
691: ? cookie->rel : NULL)
692:
693: buf = ehbuf;
694: cie_count = 0;
695: gc_mark_hook = get_elf_backend_data (abfd)->gc_mark_hook;
696: while ((bfd_size_type) (buf - ehbuf) != sec->size)
697: {
698: char *aug;
699: bfd_byte *start, *insns, *insns_end;
700: bfd_size_type length;
701: unsigned int set_loc_count;
702:
703: this_inf = sec_info->entry + sec_info->count;
704: last_fde = buf;
705:
706: /* Read the length of the entry. */
707: REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
708: hdr_length = bfd_get_32 (abfd, buf - 4);
709:
710: /* The CIE/FDE must be fully contained in this input section. */
711: REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
712: end = buf + hdr_length;
713:
714: this_inf->offset = last_fde - ehbuf;
715: this_inf->size = 4 + hdr_length;
716: this_inf->reloc_index = cookie->rel - cookie->rels;
717:
718: if (hdr_length == 0)
719: {
720: /* A zero-length CIE should only be found at the end of
1.6 christos 721: the section, but allow multiple terminators. */
722: while (skip_bytes (&buf, ehbuf + sec->size, 4))
723: REQUIRE (bfd_get_32 (abfd, buf - 4) == 0);
1.1 christos 724: REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
725: ENSURE_NO_RELOCS (buf);
726: sec_info->count++;
727: break;
728: }
729:
730: REQUIRE (skip_bytes (&buf, end, 4));
731: hdr_id = bfd_get_32 (abfd, buf - 4);
732:
733: if (hdr_id == 0)
734: {
735: unsigned int initial_insn_length;
736:
737: /* CIE */
738: this_inf->cie = 1;
739:
740: /* Point CIE to one of the section-local cie structures. */
741: cie = local_cies + cie_count++;
742:
743: cie->cie_inf = this_inf;
744: cie->length = hdr_length;
745: start = buf;
746: REQUIRE (read_byte (&buf, end, &cie->version));
747:
748: /* Cannot handle unknown versions. */
749: REQUIRE (cie->version == 1
750: || cie->version == 3
751: || cie->version == 4);
752: REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
753:
754: strcpy (cie->augmentation, (char *) buf);
755: buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
1.6 christos 756: this_inf->u.cie.aug_str_len = buf - start - 1;
1.1 christos 757: ENSURE_NO_RELOCS (buf);
758: if (buf[0] == 'e' && buf[1] == 'h')
759: {
760: /* GCC < 3.0 .eh_frame CIE */
761: /* We cannot merge "eh" CIEs because __EXCEPTION_TABLE__
762: is private to each CIE, so we don't need it for anything.
763: Just skip it. */
764: REQUIRE (skip_bytes (&buf, end, ptr_size));
765: SKIP_RELOCS (buf);
766: }
767: if (cie->version >= 4)
768: {
769: REQUIRE (buf + 1 < end);
770: REQUIRE (buf[0] == ptr_size);
771: REQUIRE (buf[1] == 0);
772: buf += 2;
773: }
774: REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
775: REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
776: if (cie->version == 1)
777: {
778: REQUIRE (buf < end);
779: cie->ra_column = *buf++;
780: }
781: else
782: REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
783: ENSURE_NO_RELOCS (buf);
784: cie->lsda_encoding = DW_EH_PE_omit;
785: cie->fde_encoding = DW_EH_PE_omit;
786: cie->per_encoding = DW_EH_PE_omit;
787: aug = cie->augmentation;
788: if (aug[0] != 'e' || aug[1] != 'h')
789: {
790: if (*aug == 'z')
791: {
792: aug++;
793: REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
1.6 christos 794: ENSURE_NO_RELOCS (buf);
1.1 christos 795: }
796:
797: while (*aug != '\0')
798: switch (*aug++)
799: {
1.7 ! christos 800: case 'B':
! 801: break;
1.1 christos 802: case 'L':
803: REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
804: ENSURE_NO_RELOCS (buf);
805: REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
806: break;
807: case 'R':
808: REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
809: ENSURE_NO_RELOCS (buf);
810: REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
811: break;
812: case 'S':
813: break;
814: case 'P':
815: {
816: int per_width;
817:
818: REQUIRE (read_byte (&buf, end, &cie->per_encoding));
819: per_width = get_DW_EH_PE_width (cie->per_encoding,
820: ptr_size);
821: REQUIRE (per_width);
822: if ((cie->per_encoding & 0x70) == DW_EH_PE_aligned)
823: {
824: length = -(buf - ehbuf) & (per_width - 1);
825: REQUIRE (skip_bytes (&buf, end, length));
1.6 christos 826: if (per_width == 8)
827: this_inf->u.cie.per_encoding_aligned8 = 1;
1.1 christos 828: }
829: this_inf->u.cie.personality_offset = buf - start;
830: ENSURE_NO_RELOCS (buf);
831: /* Ensure we have a reloc here. */
832: REQUIRE (GET_RELOC (buf));
833: cie->personality.reloc_index
834: = cookie->rel - cookie->rels;
835: /* Cope with MIPS-style composite relocations. */
836: do
837: cookie->rel++;
838: while (GET_RELOC (buf) != NULL);
839: REQUIRE (skip_bytes (&buf, end, per_width));
840: }
841: break;
842: default:
843: /* Unrecognized augmentation. Better bail out. */
844: goto free_no_table;
845: }
846: }
1.6 christos 847: this_inf->u.cie.aug_data_len
848: = buf - start - 1 - this_inf->u.cie.aug_str_len;
1.1 christos 849:
850: /* For shared libraries, try to get rid of as many RELATIVE relocs
851: as possible. */
1.3 christos 852: if (bfd_link_pic (info)
1.1 christos 853: && (get_elf_backend_data (abfd)
854: ->elf_backend_can_make_relative_eh_frame
855: (abfd, info, sec)))
856: {
857: if ((cie->fde_encoding & 0x70) == DW_EH_PE_absptr)
858: this_inf->make_relative = 1;
859: /* If the CIE doesn't already have an 'R' entry, it's fairly
860: easy to add one, provided that there's no aligned data
861: after the augmentation string. */
862: else if (cie->fde_encoding == DW_EH_PE_omit
863: && (cie->per_encoding & 0x70) != DW_EH_PE_aligned)
864: {
865: if (*cie->augmentation == 0)
866: this_inf->add_augmentation_size = 1;
867: this_inf->u.cie.add_fde_encoding = 1;
868: this_inf->make_relative = 1;
869: }
870:
871: if ((cie->lsda_encoding & 0x70) == DW_EH_PE_absptr)
872: cie->can_make_lsda_relative = 1;
873: }
874:
875: /* If FDE encoding was not specified, it defaults to
876: DW_EH_absptr. */
877: if (cie->fde_encoding == DW_EH_PE_omit)
878: cie->fde_encoding = DW_EH_PE_absptr;
879:
880: initial_insn_length = end - buf;
1.3 christos 881: cie->initial_insn_length = initial_insn_length;
882: memcpy (cie->initial_instructions, buf,
883: initial_insn_length <= sizeof (cie->initial_instructions)
884: ? initial_insn_length : sizeof (cie->initial_instructions));
1.1 christos 885: insns = buf;
886: buf += initial_insn_length;
887: ENSURE_NO_RELOCS (buf);
888:
1.3 christos 889: if (!bfd_link_relocatable (info))
890: {
891: /* Keep info for merging cies. */
892: this_inf->u.cie.u.full_cie = cie;
893: this_inf->u.cie.per_encoding_relative
894: = (cie->per_encoding & 0x70) == DW_EH_PE_pcrel;
895: }
1.1 christos 896: }
897: else
898: {
899: /* Find the corresponding CIE. */
900: unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
901: for (cie = local_cies; cie < local_cies + cie_count; cie++)
902: if (cie_offset == cie->cie_inf->offset)
903: break;
904:
905: /* Ensure this FDE references one of the CIEs in this input
906: section. */
907: REQUIRE (cie != local_cies + cie_count);
908: this_inf->u.fde.cie_inf = cie->cie_inf;
909: this_inf->make_relative = cie->cie_inf->make_relative;
910: this_inf->add_augmentation_size
911: = cie->cie_inf->add_augmentation_size;
912:
913: ENSURE_NO_RELOCS (buf);
914: if ((sec->flags & SEC_LINKER_CREATED) == 0 || cookie->rels != NULL)
915: {
916: asection *rsec;
917:
918: REQUIRE (GET_RELOC (buf));
919:
920: /* Chain together the FDEs for each section. */
1.3 christos 921: rsec = _bfd_elf_gc_mark_rsec (info, sec, gc_mark_hook,
922: cookie, NULL);
1.1 christos 923: /* RSEC will be NULL if FDE was cleared out as it was belonging to
924: a discarded SHT_GROUP. */
925: if (rsec)
926: {
927: REQUIRE (rsec->owner == abfd);
928: this_inf->u.fde.next_for_section = elf_fde_list (rsec);
929: elf_fde_list (rsec) = this_inf;
930: }
931: }
932:
933: /* Skip the initial location and address range. */
934: start = buf;
935: length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
936: REQUIRE (skip_bytes (&buf, end, 2 * length));
937:
1.3 christos 938: SKIP_RELOCS (buf - length);
939: if (!GET_RELOC (buf - length)
940: && read_value (abfd, buf - length, length, FALSE) == 0)
941: {
942: (*info->callbacks->minfo)
1.6 christos 943: /* xgettext:c-format */
944: (_("discarding zero address range FDE in %pB(%pA).\n"),
1.3 christos 945: abfd, sec);
946: this_inf->u.fde.cie_inf = NULL;
947: }
948:
1.1 christos 949: /* Skip the augmentation size, if present. */
950: if (cie->augmentation[0] == 'z')
951: REQUIRE (read_uleb128 (&buf, end, &length));
952: else
953: length = 0;
954:
955: /* Of the supported augmentation characters above, only 'L'
956: adds augmentation data to the FDE. This code would need to
957: be adjusted if any future augmentations do the same thing. */
958: if (cie->lsda_encoding != DW_EH_PE_omit)
959: {
960: SKIP_RELOCS (buf);
961: if (cie->can_make_lsda_relative && GET_RELOC (buf))
962: cie->cie_inf->u.cie.make_lsda_relative = 1;
963: this_inf->lsda_offset = buf - start;
964: /* If there's no 'z' augmentation, we don't know where the
965: CFA insns begin. Assume no padding. */
966: if (cie->augmentation[0] != 'z')
967: length = end - buf;
968: }
969:
970: /* Skip over the augmentation data. */
971: REQUIRE (skip_bytes (&buf, end, length));
972: insns = buf;
973:
974: buf = last_fde + 4 + hdr_length;
975:
976: /* For NULL RSEC (cleared FDE belonging to a discarded section)
977: the relocations are commonly cleared. We do not sanity check if
978: all these relocations are cleared as (1) relocations to
979: .gcc_except_table will remain uncleared (they will get dropped
980: with the drop of this unused FDE) and (2) BFD already safely drops
981: relocations of any type to .eh_frame by
982: elf_section_ignore_discarded_relocs.
983: TODO: The .gcc_except_table entries should be also filtered as
984: .eh_frame entries; or GCC could rather use COMDAT for them. */
985: SKIP_RELOCS (buf);
986: }
987:
988: /* Try to interpret the CFA instructions and find the first
989: padding nop. Shrink this_inf's size so that it doesn't
990: include the padding. */
991: length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
992: set_loc_count = 0;
993: insns_end = skip_non_nops (insns, end, length, &set_loc_count);
994: /* If we don't understand the CFA instructions, we can't know
995: what needs to be adjusted there. */
996: if (insns_end == NULL
997: /* For the time being we don't support DW_CFA_set_loc in
998: CIE instructions. */
999: || (set_loc_count && this_inf->cie))
1000: goto free_no_table;
1001: this_inf->size -= end - insns_end;
1002: if (insns_end != end && this_inf->cie)
1003: {
1004: cie->initial_insn_length -= end - insns_end;
1005: cie->length -= end - insns_end;
1006: }
1007: if (set_loc_count
1008: && ((cie->fde_encoding & 0x70) == DW_EH_PE_pcrel
1009: || this_inf->make_relative))
1010: {
1011: unsigned int cnt;
1012: bfd_byte *p;
1013:
1014: this_inf->set_loc = (unsigned int *)
1.6 christos 1015: bfd_malloc ((set_loc_count + 1) * sizeof (unsigned int));
1.1 christos 1016: REQUIRE (this_inf->set_loc);
1017: this_inf->set_loc[0] = set_loc_count;
1018: p = insns;
1019: cnt = 0;
1020: while (p < end)
1021: {
1022: if (*p == DW_CFA_set_loc)
1023: this_inf->set_loc[++cnt] = p + 1 - start;
1024: REQUIRE (skip_cfa_op (&p, end, length));
1025: }
1026: }
1027:
1028: this_inf->removed = 1;
1029: this_inf->fde_encoding = cie->fde_encoding;
1030: this_inf->lsda_encoding = cie->lsda_encoding;
1031: sec_info->count++;
1032: }
1033: BFD_ASSERT (sec_info->count == num_entries);
1034: BFD_ASSERT (cie_count == num_cies);
1035:
1036: elf_section_data (sec)->sec_info = sec_info;
1037: sec->sec_info_type = SEC_INFO_TYPE_EH_FRAME;
1.3 christos 1038: if (!bfd_link_relocatable (info))
1.1 christos 1039: {
1.3 christos 1040: /* Keep info for merging cies. */
1.1 christos 1041: sec_info->cies = local_cies;
1042: local_cies = NULL;
1043: }
1044: goto success;
1045:
1046: free_no_table:
1.6 christos 1047: _bfd_error_handler
1048: /* xgettext:c-format */
1049: (_("error in %pB(%pA); no .eh_frame_hdr table will be created"),
1.1 christos 1050: abfd, sec);
1.3 christos 1051: hdr_info->u.dwarf.table = FALSE;
1.1 christos 1052: if (sec_info)
1053: free (sec_info);
1054: success:
1055: if (ehbuf)
1056: free (ehbuf);
1057: if (local_cies)
1058: free (local_cies);
1059: #undef REQUIRE
1060: }
1061:
1.3 christos 1062: /* Order eh_frame_hdr entries by the VMA of their text section. */
1063:
1064: static int
1065: cmp_eh_frame_hdr (const void *a, const void *b)
1066: {
1067: bfd_vma text_a;
1068: bfd_vma text_b;
1069: asection *sec;
1070:
1071: sec = *(asection *const *)a;
1072: sec = (asection *) elf_section_data (sec)->sec_info;
1073: text_a = sec->output_section->vma + sec->output_offset;
1074: sec = *(asection *const *)b;
1075: sec = (asection *) elf_section_data (sec)->sec_info;
1076: text_b = sec->output_section->vma + sec->output_offset;
1077:
1078: if (text_a < text_b)
1079: return -1;
1080: return text_a > text_b;
1081:
1082: }
1083:
1084: /* Add space for a CANTUNWIND terminator to SEC if the text sections
1085: referenced by it and NEXT are not contiguous, or NEXT is NULL. */
1086:
1087: static void
1088: add_eh_frame_hdr_terminator (asection *sec,
1089: asection *next)
1090: {
1091: bfd_vma end;
1092: bfd_vma next_start;
1093: asection *text_sec;
1094:
1095: if (next)
1096: {
1097: /* See if there is a gap (presumably a text section without unwind info)
1098: between these two entries. */
1099: text_sec = (asection *) elf_section_data (sec)->sec_info;
1100: end = text_sec->output_section->vma + text_sec->output_offset
1101: + text_sec->size;
1102: text_sec = (asection *) elf_section_data (next)->sec_info;
1103: next_start = text_sec->output_section->vma + text_sec->output_offset;
1104: if (end == next_start)
1105: return;
1106: }
1107:
1108: /* Add space for a CANTUNWIND terminator. */
1109: if (!sec->rawsize)
1110: sec->rawsize = sec->size;
1111:
1.7 ! christos 1112: bfd_set_section_size (sec, sec->size + 8);
1.3 christos 1113: }
1114:
1115: /* Finish a pass over all .eh_frame_entry sections. */
1.1 christos 1116:
1.3 christos 1117: bfd_boolean
1.1 christos 1118: _bfd_elf_end_eh_frame_parsing (struct bfd_link_info *info)
1119: {
1120: struct eh_frame_hdr_info *hdr_info;
1.3 christos 1121: unsigned int i;
1.1 christos 1122:
1123: hdr_info = &elf_hash_table (info)->eh_info;
1.3 christos 1124:
1125: if (info->eh_frame_hdr_type != COMPACT_EH_HDR
1126: || hdr_info->array_count == 0)
1127: return FALSE;
1128:
1129: bfd_elf_discard_eh_frame_entry (hdr_info);
1130:
1131: qsort (hdr_info->u.compact.entries, hdr_info->array_count,
1132: sizeof (asection *), cmp_eh_frame_hdr);
1133:
1134: for (i = 0; i < hdr_info->array_count - 1; i++)
1135: {
1136: add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i],
1137: hdr_info->u.compact.entries[i + 1]);
1138: }
1139:
1140: /* Add a CANTUNWIND terminator after the last entry. */
1141: add_eh_frame_hdr_terminator (hdr_info->u.compact.entries[i], NULL);
1142: return TRUE;
1.1 christos 1143: }
1144:
1145: /* Mark all relocations against CIE or FDE ENT, which occurs in
1146: .eh_frame section SEC. COOKIE describes the relocations in SEC;
1147: its "rel" field can be changed freely. */
1148:
1149: static bfd_boolean
1150: mark_entry (struct bfd_link_info *info, asection *sec,
1151: struct eh_cie_fde *ent, elf_gc_mark_hook_fn gc_mark_hook,
1152: struct elf_reloc_cookie *cookie)
1153: {
1154: /* FIXME: octets_per_byte. */
1155: for (cookie->rel = cookie->rels + ent->reloc_index;
1156: cookie->rel < cookie->relend
1157: && cookie->rel->r_offset < ent->offset + ent->size;
1158: cookie->rel++)
1159: if (!_bfd_elf_gc_mark_reloc (info, sec, gc_mark_hook, cookie))
1160: return FALSE;
1161:
1162: return TRUE;
1163: }
1164:
1165: /* Mark all the relocations against FDEs that relate to code in input
1166: section SEC. The FDEs belong to .eh_frame section EH_FRAME, whose
1167: relocations are described by COOKIE. */
1168:
1169: bfd_boolean
1170: _bfd_elf_gc_mark_fdes (struct bfd_link_info *info, asection *sec,
1171: asection *eh_frame, elf_gc_mark_hook_fn gc_mark_hook,
1172: struct elf_reloc_cookie *cookie)
1173: {
1174: struct eh_cie_fde *fde, *cie;
1175:
1176: for (fde = elf_fde_list (sec); fde; fde = fde->u.fde.next_for_section)
1177: {
1178: if (!mark_entry (info, eh_frame, fde, gc_mark_hook, cookie))
1179: return FALSE;
1180:
1181: /* At this stage, all cie_inf fields point to local CIEs, so we
1182: can use the same cookie to refer to them. */
1183: cie = fde->u.fde.cie_inf;
1.3 christos 1184: if (cie != NULL && !cie->u.cie.gc_mark)
1.1 christos 1185: {
1186: cie->u.cie.gc_mark = 1;
1187: if (!mark_entry (info, eh_frame, cie, gc_mark_hook, cookie))
1188: return FALSE;
1189: }
1190: }
1191: return TRUE;
1192: }
1193:
1194: /* Input section SEC of ABFD is an .eh_frame section that contains the
1195: CIE described by CIE_INF. Return a version of CIE_INF that is going
1196: to be kept in the output, adding CIE_INF to the output if necessary.
1197:
1198: HDR_INFO is the .eh_frame_hdr information and COOKIE describes the
1199: relocations in REL. */
1200:
1201: static struct eh_cie_fde *
1202: find_merged_cie (bfd *abfd, struct bfd_link_info *info, asection *sec,
1203: struct eh_frame_hdr_info *hdr_info,
1204: struct elf_reloc_cookie *cookie,
1205: struct eh_cie_fde *cie_inf)
1206: {
1207: unsigned long r_symndx;
1208: struct cie *cie, *new_cie;
1209: Elf_Internal_Rela *rel;
1210: void **loc;
1211:
1212: /* Use CIE_INF if we have already decided to keep it. */
1213: if (!cie_inf->removed)
1214: return cie_inf;
1215:
1216: /* If we have merged CIE_INF with another CIE, use that CIE instead. */
1217: if (cie_inf->u.cie.merged)
1218: return cie_inf->u.cie.u.merged_with;
1219:
1220: cie = cie_inf->u.cie.u.full_cie;
1221:
1222: /* Assume we will need to keep CIE_INF. */
1223: cie_inf->removed = 0;
1224: cie_inf->u.cie.u.sec = sec;
1225:
1226: /* If we are not merging CIEs, use CIE_INF. */
1227: if (cie == NULL)
1228: return cie_inf;
1229:
1230: if (cie->per_encoding != DW_EH_PE_omit)
1231: {
1232: bfd_boolean per_binds_local;
1233:
1.3 christos 1234: /* Work out the address of personality routine, or at least
1235: enough info that we could calculate the address had we made a
1236: final section layout. The symbol on the reloc is enough,
1237: either the hash for a global, or (bfd id, index) pair for a
1238: local. The assumption here is that no one uses addends on
1239: the reloc. */
1.1 christos 1240: rel = cookie->rels + cie->personality.reloc_index;
1241: memset (&cie->personality, 0, sizeof (cie->personality));
1242: #ifdef BFD64
1243: if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64)
1244: r_symndx = ELF64_R_SYM (rel->r_info);
1245: else
1246: #endif
1247: r_symndx = ELF32_R_SYM (rel->r_info);
1248: if (r_symndx >= cookie->locsymcount
1249: || ELF_ST_BIND (cookie->locsyms[r_symndx].st_info) != STB_LOCAL)
1250: {
1251: struct elf_link_hash_entry *h;
1252:
1253: r_symndx -= cookie->extsymoff;
1254: h = cookie->sym_hashes[r_symndx];
1255:
1256: while (h->root.type == bfd_link_hash_indirect
1257: || h->root.type == bfd_link_hash_warning)
1258: h = (struct elf_link_hash_entry *) h->root.u.i.link;
1259:
1260: cie->personality.h = h;
1261: per_binds_local = SYMBOL_REFERENCES_LOCAL (info, h);
1262: }
1263: else
1264: {
1265: Elf_Internal_Sym *sym;
1266: asection *sym_sec;
1267:
1268: sym = &cookie->locsyms[r_symndx];
1269: sym_sec = bfd_section_from_elf_index (abfd, sym->st_shndx);
1270: if (sym_sec == NULL)
1271: return cie_inf;
1272:
1273: if (sym_sec->kept_section != NULL)
1274: sym_sec = sym_sec->kept_section;
1275: if (sym_sec->output_section == NULL)
1276: return cie_inf;
1277:
1278: cie->local_personality = 1;
1.3 christos 1279: cie->personality.sym.bfd_id = abfd->id;
1280: cie->personality.sym.index = r_symndx;
1.1 christos 1281: per_binds_local = TRUE;
1282: }
1283:
1284: if (per_binds_local
1.3 christos 1285: && bfd_link_pic (info)
1.1 christos 1286: && (cie->per_encoding & 0x70) == DW_EH_PE_absptr
1287: && (get_elf_backend_data (abfd)
1288: ->elf_backend_can_make_relative_eh_frame (abfd, info, sec)))
1289: {
1290: cie_inf->u.cie.make_per_encoding_relative = 1;
1291: cie_inf->u.cie.per_encoding_relative = 1;
1292: }
1293: }
1294:
1295: /* See if we can merge this CIE with an earlier one. */
1296: cie_compute_hash (cie);
1.3 christos 1297: if (hdr_info->u.dwarf.cies == NULL)
1.1 christos 1298: {
1.3 christos 1299: hdr_info->u.dwarf.cies = htab_try_create (1, cie_hash, cie_eq, free);
1300: if (hdr_info->u.dwarf.cies == NULL)
1.1 christos 1301: return cie_inf;
1302: }
1.3 christos 1303: loc = htab_find_slot_with_hash (hdr_info->u.dwarf.cies, cie,
1304: cie->hash, INSERT);
1.1 christos 1305: if (loc == NULL)
1306: return cie_inf;
1307:
1308: new_cie = (struct cie *) *loc;
1309: if (new_cie == NULL)
1310: {
1311: /* Keep CIE_INF and record it in the hash table. */
1312: new_cie = (struct cie *) malloc (sizeof (struct cie));
1313: if (new_cie == NULL)
1314: return cie_inf;
1315:
1316: memcpy (new_cie, cie, sizeof (struct cie));
1317: *loc = new_cie;
1318: }
1319: else
1320: {
1321: /* Merge CIE_INF with NEW_CIE->CIE_INF. */
1322: cie_inf->removed = 1;
1323: cie_inf->u.cie.merged = 1;
1324: cie_inf->u.cie.u.merged_with = new_cie->cie_inf;
1325: if (cie_inf->u.cie.make_lsda_relative)
1326: new_cie->cie_inf->u.cie.make_lsda_relative = 1;
1327: }
1328: return new_cie->cie_inf;
1329: }
1330:
1.6 christos 1331: /* For a given OFFSET in SEC, return the delta to the new location
1332: after .eh_frame editing. */
1333:
1334: static bfd_signed_vma
1335: offset_adjust (bfd_vma offset, const asection *sec)
1336: {
1337: struct eh_frame_sec_info *sec_info
1338: = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1339: unsigned int lo, hi, mid;
1340: struct eh_cie_fde *ent = NULL;
1341: bfd_signed_vma delta;
1342:
1343: lo = 0;
1344: hi = sec_info->count;
1345: if (hi == 0)
1346: return 0;
1347:
1348: while (lo < hi)
1349: {
1350: mid = (lo + hi) / 2;
1351: ent = &sec_info->entry[mid];
1352: if (offset < ent->offset)
1353: hi = mid;
1354: else if (mid + 1 >= hi)
1355: break;
1356: else if (offset >= ent[1].offset)
1357: lo = mid + 1;
1358: else
1359: break;
1360: }
1361:
1362: if (!ent->removed)
1363: delta = (bfd_vma) ent->new_offset - (bfd_vma) ent->offset;
1364: else if (ent->cie && ent->u.cie.merged)
1365: {
1366: struct eh_cie_fde *cie = ent->u.cie.u.merged_with;
1367: delta = ((bfd_vma) cie->new_offset + cie->u.cie.u.sec->output_offset
1368: - (bfd_vma) ent->offset - sec->output_offset);
1369: }
1370: else
1371: {
1372: /* Is putting the symbol on the next entry best for a deleted
1373: CIE/FDE? */
1374: struct eh_cie_fde *last = sec_info->entry + sec_info->count;
1375: delta = ((bfd_vma) next_cie_fde_offset (ent, last, sec)
1376: - (bfd_vma) ent->offset);
1377: return delta;
1378: }
1379:
1380: /* Account for editing within this CIE/FDE. */
1381: offset -= ent->offset;
1382: if (ent->cie)
1383: {
1384: unsigned int extra
1385: = ent->add_augmentation_size + ent->u.cie.add_fde_encoding;
1386: if (extra == 0
1387: || offset <= 9u + ent->u.cie.aug_str_len)
1388: return delta;
1389: delta += extra;
1390: if (offset <= 9u + ent->u.cie.aug_str_len + ent->u.cie.aug_data_len)
1391: return delta;
1392: delta += extra;
1393: }
1394: else
1395: {
1396: unsigned int ptr_size, width, extra = ent->add_augmentation_size;
1397: if (offset <= 12 || extra == 0)
1398: return delta;
1399: ptr_size = (get_elf_backend_data (sec->owner)
1400: ->elf_backend_eh_frame_address_size (sec->owner, sec));
1401: width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1402: if (offset <= 8 + 2 * width)
1403: return delta;
1404: delta += extra;
1405: }
1406:
1407: return delta;
1408: }
1409:
1410: /* Adjust a global symbol defined in .eh_frame, so that it stays
1411: relative to its original CIE/FDE. It is assumed that a symbol
1412: defined at the beginning of a CIE/FDE belongs to that CIE/FDE
1413: rather than marking the end of the previous CIE/FDE. This matters
1414: when a CIE is merged with a previous CIE, since the symbol is
1415: moved to the merged CIE. */
1416:
1417: bfd_boolean
1418: _bfd_elf_adjust_eh_frame_global_symbol (struct elf_link_hash_entry *h,
1419: void *arg ATTRIBUTE_UNUSED)
1420: {
1421: asection *sym_sec;
1422: bfd_signed_vma delta;
1423:
1424: if (h->root.type != bfd_link_hash_defined
1425: && h->root.type != bfd_link_hash_defweak)
1426: return TRUE;
1427:
1428: sym_sec = h->root.u.def.section;
1429: if (sym_sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME
1430: || elf_section_data (sym_sec)->sec_info == NULL)
1431: return TRUE;
1432:
1433: delta = offset_adjust (h->root.u.def.value, sym_sec);
1434: h->root.u.def.value += delta;
1435:
1436: return TRUE;
1437: }
1438:
1439: /* The same for all local symbols defined in .eh_frame. Returns true
1440: if any symbol was changed. */
1441:
1442: static int
1443: adjust_eh_frame_local_symbols (const asection *sec,
1444: struct elf_reloc_cookie *cookie)
1445: {
1446: unsigned int shndx;
1447: Elf_Internal_Sym *sym;
1448: Elf_Internal_Sym *end_sym;
1449: int adjusted = 0;
1450:
1451: shndx = elf_section_data (sec)->this_idx;
1452: end_sym = cookie->locsyms + cookie->locsymcount;
1453: for (sym = cookie->locsyms + 1; sym < end_sym; ++sym)
1454: if (sym->st_info <= ELF_ST_INFO (STB_LOCAL, STT_OBJECT)
1455: && sym->st_shndx == shndx)
1456: {
1457: bfd_signed_vma delta = offset_adjust (sym->st_value, sec);
1458:
1459: if (delta != 0)
1460: {
1461: adjusted = 1;
1462: sym->st_value += delta;
1463: }
1464: }
1465: return adjusted;
1466: }
1467:
1.1 christos 1468: /* This function is called for each input file before the .eh_frame
1469: section is relocated. It discards duplicate CIEs and FDEs for discarded
1470: functions. The function returns TRUE iff any entries have been
1471: deleted. */
1472:
1473: bfd_boolean
1474: _bfd_elf_discard_section_eh_frame
1475: (bfd *abfd, struct bfd_link_info *info, asection *sec,
1476: bfd_boolean (*reloc_symbol_deleted_p) (bfd_vma, void *),
1477: struct elf_reloc_cookie *cookie)
1478: {
1479: struct eh_cie_fde *ent;
1480: struct eh_frame_sec_info *sec_info;
1481: struct eh_frame_hdr_info *hdr_info;
1.6 christos 1482: unsigned int ptr_size, offset, eh_alignment;
1483: int changed;
1.1 christos 1484:
1485: if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1486: return FALSE;
1487:
1488: sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1489: if (sec_info == NULL)
1490: return FALSE;
1491:
1492: ptr_size = (get_elf_backend_data (sec->owner)
1493: ->elf_backend_eh_frame_address_size (sec->owner, sec));
1494:
1495: hdr_info = &elf_hash_table (info)->eh_info;
1496: for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1497: if (ent->size == 4)
1498: /* There should only be one zero terminator, on the last input
1499: file supplying .eh_frame (crtend.o). Remove any others. */
1500: ent->removed = sec->map_head.s != NULL;
1.3 christos 1501: else if (!ent->cie && ent->u.fde.cie_inf != NULL)
1.1 christos 1502: {
1503: bfd_boolean keep;
1504: if ((sec->flags & SEC_LINKER_CREATED) != 0 && cookie->rels == NULL)
1505: {
1506: unsigned int width
1507: = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1508: bfd_vma value
1509: = read_value (abfd, sec->contents + ent->offset + 8 + width,
1510: width, get_DW_EH_PE_signed (ent->fde_encoding));
1511: keep = value != 0;
1512: }
1513: else
1514: {
1515: cookie->rel = cookie->rels + ent->reloc_index;
1516: /* FIXME: octets_per_byte. */
1517: BFD_ASSERT (cookie->rel < cookie->relend
1518: && cookie->rel->r_offset == ent->offset + 8);
1519: keep = !(*reloc_symbol_deleted_p) (ent->offset + 8, cookie);
1520: }
1521: if (keep)
1522: {
1.3 christos 1523: if (bfd_link_pic (info)
1.1 christos 1524: && (((ent->fde_encoding & 0x70) == DW_EH_PE_absptr
1525: && ent->make_relative == 0)
1526: || (ent->fde_encoding & 0x70) == DW_EH_PE_aligned))
1527: {
1.5 christos 1528: static int num_warnings_issued = 0;
1529:
1.1 christos 1530: /* If a shared library uses absolute pointers
1531: which we cannot turn into PC relative,
1532: don't create the binary search table,
1533: since it is affected by runtime relocations. */
1.3 christos 1534: hdr_info->u.dwarf.table = FALSE;
1.7 ! christos 1535: /* Only warn if --eh-frame-hdr was specified. */
! 1536: if (info->eh_frame_hdr_type != 0)
1.5 christos 1537: {
1.7 ! christos 1538: if (num_warnings_issued < 10)
! 1539: {
! 1540: _bfd_error_handler
! 1541: /* xgettext:c-format */
! 1542: (_("FDE encoding in %pB(%pA) prevents .eh_frame_hdr"
! 1543: " table being created"), abfd, sec);
! 1544: num_warnings_issued ++;
! 1545: }
! 1546: else if (num_warnings_issued == 10)
! 1547: {
! 1548: _bfd_error_handler
! 1549: (_("further warnings about FDE encoding preventing .eh_frame_hdr generation dropped"));
! 1550: num_warnings_issued ++;
! 1551: }
1.5 christos 1552: }
1.1 christos 1553: }
1554: ent->removed = 0;
1.3 christos 1555: hdr_info->u.dwarf.fde_count++;
1.1 christos 1556: ent->u.fde.cie_inf = find_merged_cie (abfd, info, sec, hdr_info,
1557: cookie, ent->u.fde.cie_inf);
1558: }
1559: }
1560:
1561: if (sec_info->cies)
1562: {
1563: free (sec_info->cies);
1564: sec_info->cies = NULL;
1565: }
1566:
1.6 christos 1567: /* It may be that some .eh_frame input section has greater alignment
1568: than other .eh_frame sections. In that case we run the risk of
1569: padding with zeros before that section, which would be seen as a
1570: zero terminator. Alignment padding must be added *inside* the
1571: last FDE instead. For other FDEs we align according to their
1572: encoding, in order to align FDE address range entries naturally. */
1.1 christos 1573: offset = 0;
1.6 christos 1574: changed = 0;
1.1 christos 1575: for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1576: if (!ent->removed)
1577: {
1.6 christos 1578: eh_alignment = 4;
1579: if (ent->size == 4)
1580: ;
1581: else if (ent->cie)
1582: {
1583: if (ent->u.cie.per_encoding_aligned8)
1584: eh_alignment = 8;
1585: }
1586: else
1587: {
1588: eh_alignment = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
1589: if (eh_alignment < 4)
1590: eh_alignment = 4;
1591: }
1592: offset = (offset + eh_alignment - 1) & -eh_alignment;
1.1 christos 1593: ent->new_offset = offset;
1.6 christos 1594: if (ent->new_offset != ent->offset)
1595: changed = 1;
1596: offset += size_of_output_cie_fde (ent);
1.1 christos 1597: }
1598:
1.6 christos 1599: eh_alignment = 4;
1600: offset = (offset + eh_alignment - 1) & -eh_alignment;
1.1 christos 1601: sec->rawsize = sec->size;
1602: sec->size = offset;
1.6 christos 1603: if (sec->size != sec->rawsize)
1604: changed = 1;
1605:
1606: if (changed && adjust_eh_frame_local_symbols (sec, cookie))
1607: {
1608: Elf_Internal_Shdr *symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1609: symtab_hdr->contents = (unsigned char *) cookie->locsyms;
1610: }
1611: return changed;
1.1 christos 1612: }
1613:
1614: /* This function is called for .eh_frame_hdr section after
1615: _bfd_elf_discard_section_eh_frame has been called on all .eh_frame
1616: input sections. It finalizes the size of .eh_frame_hdr section. */
1617:
1618: bfd_boolean
1619: _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1620: {
1621: struct elf_link_hash_table *htab;
1622: struct eh_frame_hdr_info *hdr_info;
1623: asection *sec;
1624:
1625: htab = elf_hash_table (info);
1626: hdr_info = &htab->eh_info;
1627:
1.3 christos 1628: if (!hdr_info->frame_hdr_is_compact && hdr_info->u.dwarf.cies != NULL)
1.1 christos 1629: {
1.3 christos 1630: htab_delete (hdr_info->u.dwarf.cies);
1631: hdr_info->u.dwarf.cies = NULL;
1.1 christos 1632: }
1633:
1634: sec = hdr_info->hdr_sec;
1635: if (sec == NULL)
1636: return FALSE;
1637:
1.3 christos 1638: if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
1639: {
1640: /* For compact frames we only add the header. The actual table comes
1.6 christos 1641: from the .eh_frame_entry sections. */
1.3 christos 1642: sec->size = 8;
1643: }
1644: else
1645: {
1646: sec->size = EH_FRAME_HDR_SIZE;
1647: if (hdr_info->u.dwarf.table)
1648: sec->size += 4 + hdr_info->u.dwarf.fde_count * 8;
1649: }
1.1 christos 1650:
1.3 christos 1651: elf_eh_frame_hdr (abfd) = sec;
1.1 christos 1652: return TRUE;
1653: }
1654:
1655: /* Return true if there is at least one non-empty .eh_frame section in
1656: input files. Can only be called after ld has mapped input to
1657: output sections, and before sections are stripped. */
1.3 christos 1658:
1.1 christos 1659: bfd_boolean
1660: _bfd_elf_eh_frame_present (struct bfd_link_info *info)
1661: {
1662: asection *eh = bfd_get_section_by_name (info->output_bfd, ".eh_frame");
1663:
1664: if (eh == NULL)
1665: return FALSE;
1666:
1667: /* Count only sections which have at least a single CIE or FDE.
1668: There cannot be any CIE or FDE <= 8 bytes. */
1669: for (eh = eh->map_head.s; eh != NULL; eh = eh->map_head.s)
1670: if (eh->size > 8)
1671: return TRUE;
1672:
1673: return FALSE;
1674: }
1675:
1.3 christos 1676: /* Return true if there is at least one .eh_frame_entry section in
1677: input files. */
1678:
1679: bfd_boolean
1680: _bfd_elf_eh_frame_entry_present (struct bfd_link_info *info)
1681: {
1682: asection *o;
1683: bfd *abfd;
1684:
1685: for (abfd = info->input_bfds; abfd != NULL; abfd = abfd->link.next)
1686: {
1687: for (o = abfd->sections; o; o = o->next)
1688: {
1.7 ! christos 1689: const char *name = bfd_section_name (o);
1.3 christos 1690:
1691: if (strcmp (name, ".eh_frame_entry")
1692: && !bfd_is_abs_section (o->output_section))
1693: return TRUE;
1694: }
1695: }
1696: return FALSE;
1697: }
1698:
1.1 christos 1699: /* This function is called from size_dynamic_sections.
1700: It needs to decide whether .eh_frame_hdr should be output or not,
1701: because when the dynamic symbol table has been sized it is too late
1702: to strip sections. */
1703:
1704: bfd_boolean
1705: _bfd_elf_maybe_strip_eh_frame_hdr (struct bfd_link_info *info)
1706: {
1707: struct elf_link_hash_table *htab;
1708: struct eh_frame_hdr_info *hdr_info;
1.3 christos 1709: struct bfd_link_hash_entry *bh = NULL;
1710: struct elf_link_hash_entry *h;
1.1 christos 1711:
1712: htab = elf_hash_table (info);
1713: hdr_info = &htab->eh_info;
1714: if (hdr_info->hdr_sec == NULL)
1715: return TRUE;
1716:
1717: if (bfd_is_abs_section (hdr_info->hdr_sec->output_section)
1.3 christos 1718: || info->eh_frame_hdr_type == 0
1719: || (info->eh_frame_hdr_type == DWARF2_EH_HDR
1720: && !_bfd_elf_eh_frame_present (info))
1721: || (info->eh_frame_hdr_type == COMPACT_EH_HDR
1722: && !_bfd_elf_eh_frame_entry_present (info)))
1.1 christos 1723: {
1724: hdr_info->hdr_sec->flags |= SEC_EXCLUDE;
1725: hdr_info->hdr_sec = NULL;
1726: return TRUE;
1727: }
1728:
1.3 christos 1729: /* Add a hidden symbol so that systems without access to PHDRs can
1730: find the table. */
1731: if (! (_bfd_generic_link_add_one_symbol
1732: (info, info->output_bfd, "__GNU_EH_FRAME_HDR", BSF_LOCAL,
1733: hdr_info->hdr_sec, 0, NULL, FALSE, FALSE, &bh)))
1734: return FALSE;
1735:
1736: h = (struct elf_link_hash_entry *) bh;
1737: h->def_regular = 1;
1738: h->other = STV_HIDDEN;
1739: get_elf_backend_data
1740: (info->output_bfd)->elf_backend_hide_symbol (info, h, TRUE);
1741:
1742: if (!hdr_info->frame_hdr_is_compact)
1743: hdr_info->u.dwarf.table = TRUE;
1.1 christos 1744: return TRUE;
1745: }
1746:
1747: /* Adjust an address in the .eh_frame section. Given OFFSET within
1748: SEC, this returns the new offset in the adjusted .eh_frame section,
1749: or -1 if the address refers to a CIE/FDE which has been removed
1750: or to offset with dynamic relocation which is no longer needed. */
1751:
1752: bfd_vma
1753: _bfd_elf_eh_frame_section_offset (bfd *output_bfd ATTRIBUTE_UNUSED,
1754: struct bfd_link_info *info ATTRIBUTE_UNUSED,
1755: asection *sec,
1756: bfd_vma offset)
1757: {
1758: struct eh_frame_sec_info *sec_info;
1759: unsigned int lo, hi, mid;
1760:
1761: if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1762: return offset;
1763: sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1764:
1765: if (offset >= sec->rawsize)
1766: return offset - sec->rawsize + sec->size;
1767:
1768: lo = 0;
1769: hi = sec_info->count;
1770: mid = 0;
1771: while (lo < hi)
1772: {
1773: mid = (lo + hi) / 2;
1774: if (offset < sec_info->entry[mid].offset)
1775: hi = mid;
1776: else if (offset
1777: >= sec_info->entry[mid].offset + sec_info->entry[mid].size)
1778: lo = mid + 1;
1779: else
1780: break;
1781: }
1782:
1783: BFD_ASSERT (lo < hi);
1784:
1785: /* FDE or CIE was removed. */
1786: if (sec_info->entry[mid].removed)
1787: return (bfd_vma) -1;
1788:
1789: /* If converting personality pointers to DW_EH_PE_pcrel, there will be
1790: no need for run-time relocation against the personality field. */
1791: if (sec_info->entry[mid].cie
1792: && sec_info->entry[mid].u.cie.make_per_encoding_relative
1793: && offset == (sec_info->entry[mid].offset + 8
1794: + sec_info->entry[mid].u.cie.personality_offset))
1795: return (bfd_vma) -2;
1796:
1797: /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1798: relocation against FDE's initial_location field. */
1799: if (!sec_info->entry[mid].cie
1800: && sec_info->entry[mid].make_relative
1801: && offset == sec_info->entry[mid].offset + 8)
1802: return (bfd_vma) -2;
1803:
1804: /* If converting LSDA pointers to DW_EH_PE_pcrel, there will be no need
1805: for run-time relocation against LSDA field. */
1806: if (!sec_info->entry[mid].cie
1807: && sec_info->entry[mid].u.fde.cie_inf->u.cie.make_lsda_relative
1808: && offset == (sec_info->entry[mid].offset + 8
1809: + sec_info->entry[mid].lsda_offset))
1810: return (bfd_vma) -2;
1811:
1812: /* If converting to DW_EH_PE_pcrel, there will be no need for run-time
1813: relocation against DW_CFA_set_loc's arguments. */
1814: if (sec_info->entry[mid].set_loc
1815: && sec_info->entry[mid].make_relative
1816: && (offset >= sec_info->entry[mid].offset + 8
1817: + sec_info->entry[mid].set_loc[1]))
1818: {
1819: unsigned int cnt;
1820:
1821: for (cnt = 1; cnt <= sec_info->entry[mid].set_loc[0]; cnt++)
1822: if (offset == sec_info->entry[mid].offset + 8
1823: + sec_info->entry[mid].set_loc[cnt])
1824: return (bfd_vma) -2;
1825: }
1826:
1827: /* Any new augmentation bytes go before the first relocation. */
1828: return (offset + sec_info->entry[mid].new_offset
1829: - sec_info->entry[mid].offset
1830: + extra_augmentation_string_bytes (sec_info->entry + mid)
1831: + extra_augmentation_data_bytes (sec_info->entry + mid));
1832: }
1833:
1.3 christos 1834: /* Write out .eh_frame_entry section. Add CANTUNWIND terminator if needed.
1835: Also check that the contents look sane. */
1836:
1837: bfd_boolean
1838: _bfd_elf_write_section_eh_frame_entry (bfd *abfd, struct bfd_link_info *info,
1839: asection *sec, bfd_byte *contents)
1840: {
1841: const struct elf_backend_data *bed;
1842: bfd_byte cantunwind[8];
1843: bfd_vma addr;
1844: bfd_vma last_addr;
1845: bfd_vma offset;
1846: asection *text_sec = (asection *) elf_section_data (sec)->sec_info;
1847:
1848: if (!sec->rawsize)
1849: sec->rawsize = sec->size;
1850:
1851: BFD_ASSERT (sec->sec_info_type == SEC_INFO_TYPE_EH_FRAME_ENTRY);
1852:
1853: /* Check to make sure that the text section corresponding to this eh_frame_entry
1854: section has not been excluded. In particular, mips16 stub entries will be
1855: excluded outside of the normal process. */
1856: if (sec->flags & SEC_EXCLUDE
1857: || text_sec->flags & SEC_EXCLUDE)
1858: return TRUE;
1859:
1860: if (!bfd_set_section_contents (abfd, sec->output_section, contents,
1861: sec->output_offset, sec->rawsize))
1862: return FALSE;
1863:
1864: last_addr = bfd_get_signed_32 (abfd, contents);
1865: /* Check that all the entries are in order. */
1866: for (offset = 8; offset < sec->rawsize; offset += 8)
1867: {
1868: addr = bfd_get_signed_32 (abfd, contents + offset) + offset;
1869: if (addr <= last_addr)
1870: {
1.6 christos 1871: /* xgettext:c-format */
1872: _bfd_error_handler (_("%pB: %pA not in order"), sec->owner, sec);
1.3 christos 1873: return FALSE;
1874: }
1875:
1876: last_addr = addr;
1877: }
1878:
1879: addr = text_sec->output_section->vma + text_sec->output_offset
1880: + text_sec->size;
1881: addr &= ~1;
1882: addr -= (sec->output_section->vma + sec->output_offset + sec->rawsize);
1883: if (addr & 1)
1884: {
1.6 christos 1885: /* xgettext:c-format */
1886: _bfd_error_handler (_("%pB: %pA invalid input section size"),
1887: sec->owner, sec);
1.3 christos 1888: bfd_set_error (bfd_error_bad_value);
1889: return FALSE;
1890: }
1891: if (last_addr >= addr + sec->rawsize)
1892: {
1.6 christos 1893: /* xgettext:c-format */
1894: _bfd_error_handler (_("%pB: %pA points past end of text section"),
1895: sec->owner, sec);
1.3 christos 1896: bfd_set_error (bfd_error_bad_value);
1897: return FALSE;
1898: }
1899:
1900: if (sec->size == sec->rawsize)
1901: return TRUE;
1902:
1903: bed = get_elf_backend_data (abfd);
1904: BFD_ASSERT (sec->size == sec->rawsize + 8);
1905: BFD_ASSERT ((addr & 1) == 0);
1906: BFD_ASSERT (bed->cant_unwind_opcode);
1907:
1908: bfd_put_32 (abfd, addr, cantunwind);
1909: bfd_put_32 (abfd, (*bed->cant_unwind_opcode) (info), cantunwind + 4);
1910: return bfd_set_section_contents (abfd, sec->output_section, cantunwind,
1911: sec->output_offset + sec->rawsize, 8);
1912: }
1913:
1.1 christos 1914: /* Write out .eh_frame section. This is called with the relocated
1915: contents. */
1916:
1917: bfd_boolean
1918: _bfd_elf_write_section_eh_frame (bfd *abfd,
1919: struct bfd_link_info *info,
1920: asection *sec,
1921: bfd_byte *contents)
1922: {
1923: struct eh_frame_sec_info *sec_info;
1924: struct elf_link_hash_table *htab;
1925: struct eh_frame_hdr_info *hdr_info;
1926: unsigned int ptr_size;
1.6 christos 1927: struct eh_cie_fde *ent, *last_ent;
1.1 christos 1928:
1929: if (sec->sec_info_type != SEC_INFO_TYPE_EH_FRAME)
1930: /* FIXME: octets_per_byte. */
1931: return bfd_set_section_contents (abfd, sec->output_section, contents,
1932: sec->output_offset, sec->size);
1933:
1934: ptr_size = (get_elf_backend_data (abfd)
1935: ->elf_backend_eh_frame_address_size (abfd, sec));
1936: BFD_ASSERT (ptr_size != 0);
1937:
1938: sec_info = (struct eh_frame_sec_info *) elf_section_data (sec)->sec_info;
1939: htab = elf_hash_table (info);
1940: hdr_info = &htab->eh_info;
1941:
1.3 christos 1942: if (hdr_info->u.dwarf.table && hdr_info->u.dwarf.array == NULL)
1943: {
1944: hdr_info->frame_hdr_is_compact = FALSE;
1945: hdr_info->u.dwarf.array = (struct eh_frame_array_ent *)
1.6 christos 1946: bfd_malloc (hdr_info->u.dwarf.fde_count
1.3 christos 1947: * sizeof (*hdr_info->u.dwarf.array));
1948: }
1949: if (hdr_info->u.dwarf.array == NULL)
1.1 christos 1950: hdr_info = NULL;
1951:
1952: /* The new offsets can be bigger or smaller than the original offsets.
1953: We therefore need to make two passes over the section: one backward
1954: pass to move entries up and one forward pass to move entries down.
1955: The two passes won't interfere with each other because entries are
1956: not reordered */
1957: for (ent = sec_info->entry + sec_info->count; ent-- != sec_info->entry;)
1958: if (!ent->removed && ent->new_offset > ent->offset)
1959: memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1960:
1961: for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
1962: if (!ent->removed && ent->new_offset < ent->offset)
1963: memmove (contents + ent->new_offset, contents + ent->offset, ent->size);
1964:
1.6 christos 1965: last_ent = sec_info->entry + sec_info->count;
1966: for (ent = sec_info->entry; ent < last_ent; ++ent)
1.1 christos 1967: {
1968: unsigned char *buf, *end;
1969: unsigned int new_size;
1970:
1971: if (ent->removed)
1972: continue;
1973:
1974: if (ent->size == 4)
1975: {
1976: /* Any terminating FDE must be at the end of the section. */
1.6 christos 1977: BFD_ASSERT (ent == last_ent - 1);
1.1 christos 1978: continue;
1979: }
1980:
1981: buf = contents + ent->new_offset;
1982: end = buf + ent->size;
1.6 christos 1983: new_size = next_cie_fde_offset (ent, last_ent, sec) - ent->new_offset;
1.1 christos 1984:
1985: /* Update the size. It may be shrinked. */
1986: bfd_put_32 (abfd, new_size - 4, buf);
1987:
1988: /* Filling the extra bytes with DW_CFA_nops. */
1989: if (new_size != ent->size)
1990: memset (end, 0, new_size - ent->size);
1991:
1992: if (ent->cie)
1993: {
1994: /* CIE */
1995: if (ent->make_relative
1996: || ent->u.cie.make_lsda_relative
1997: || ent->u.cie.per_encoding_relative)
1998: {
1999: char *aug;
1.7 ! christos 2000: unsigned int version, action, extra_string, extra_data;
1.1 christos 2001: unsigned int per_width, per_encoding;
2002:
2003: /* Need to find 'R' or 'L' augmentation's argument and modify
2004: DW_EH_PE_* value. */
2005: action = ((ent->make_relative ? 1 : 0)
2006: | (ent->u.cie.make_lsda_relative ? 2 : 0)
2007: | (ent->u.cie.per_encoding_relative ? 4 : 0));
2008: extra_string = extra_augmentation_string_bytes (ent);
2009: extra_data = extra_augmentation_data_bytes (ent);
2010:
1.7 ! christos 2011: /* Skip length, id. */
! 2012: buf += 8;
! 2013: version = *buf++;
1.1 christos 2014: aug = (char *) buf;
2015: buf += strlen (aug) + 1;
2016: skip_leb128 (&buf, end);
2017: skip_leb128 (&buf, end);
1.7 ! christos 2018: if (version == 1)
! 2019: skip_bytes (&buf, end, 1);
! 2020: else
! 2021: skip_leb128 (&buf, end);
1.1 christos 2022: if (*aug == 'z')
2023: {
2024: /* The uleb128 will always be a single byte for the kind
2025: of augmentation strings that we're prepared to handle. */
2026: *buf++ += extra_data;
2027: aug++;
2028: }
2029:
2030: /* Make room for the new augmentation string and data bytes. */
2031: memmove (buf + extra_string + extra_data, buf, end - buf);
2032: memmove (aug + extra_string, aug, buf - (bfd_byte *) aug);
2033: buf += extra_string;
2034: end += extra_string + extra_data;
2035:
2036: if (ent->add_augmentation_size)
2037: {
2038: *aug++ = 'z';
2039: *buf++ = extra_data - 1;
2040: }
2041: if (ent->u.cie.add_fde_encoding)
2042: {
2043: BFD_ASSERT (action & 1);
2044: *aug++ = 'R';
2045: *buf++ = make_pc_relative (DW_EH_PE_absptr, ptr_size);
2046: action &= ~1;
2047: }
2048:
2049: while (action)
2050: switch (*aug++)
2051: {
2052: case 'L':
2053: if (action & 2)
2054: {
2055: BFD_ASSERT (*buf == ent->lsda_encoding);
2056: *buf = make_pc_relative (*buf, ptr_size);
2057: action &= ~2;
2058: }
2059: buf++;
2060: break;
2061: case 'P':
2062: if (ent->u.cie.make_per_encoding_relative)
2063: *buf = make_pc_relative (*buf, ptr_size);
2064: per_encoding = *buf++;
2065: per_width = get_DW_EH_PE_width (per_encoding, ptr_size);
2066: BFD_ASSERT (per_width != 0);
2067: BFD_ASSERT (((per_encoding & 0x70) == DW_EH_PE_pcrel)
2068: == ent->u.cie.per_encoding_relative);
2069: if ((per_encoding & 0x70) == DW_EH_PE_aligned)
2070: buf = (contents
2071: + ((buf - contents + per_width - 1)
2072: & ~((bfd_size_type) per_width - 1)));
2073: if (action & 4)
2074: {
2075: bfd_vma val;
2076:
2077: val = read_value (abfd, buf, per_width,
2078: get_DW_EH_PE_signed (per_encoding));
2079: if (ent->u.cie.make_per_encoding_relative)
2080: val -= (sec->output_section->vma
2081: + sec->output_offset
2082: + (buf - contents));
2083: else
2084: {
2085: val += (bfd_vma) ent->offset - ent->new_offset;
2086: val -= extra_string + extra_data;
2087: }
2088: write_value (abfd, buf, val, per_width);
2089: action &= ~4;
2090: }
2091: buf += per_width;
2092: break;
2093: case 'R':
2094: if (action & 1)
2095: {
2096: BFD_ASSERT (*buf == ent->fde_encoding);
2097: *buf = make_pc_relative (*buf, ptr_size);
2098: action &= ~1;
2099: }
2100: buf++;
2101: break;
2102: case 'S':
2103: break;
2104: default:
2105: BFD_FAIL ();
2106: }
2107: }
2108: }
2109: else
2110: {
2111: /* FDE */
2112: bfd_vma value, address;
2113: unsigned int width;
2114: bfd_byte *start;
2115: struct eh_cie_fde *cie;
2116:
2117: /* Skip length. */
2118: cie = ent->u.fde.cie_inf;
2119: buf += 4;
2120: value = ((ent->new_offset + sec->output_offset + 4)
2121: - (cie->new_offset + cie->u.cie.u.sec->output_offset));
2122: bfd_put_32 (abfd, value, buf);
1.3 christos 2123: if (bfd_link_relocatable (info))
2124: continue;
1.1 christos 2125: buf += 4;
2126: width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2127: value = read_value (abfd, buf, width,
2128: get_DW_EH_PE_signed (ent->fde_encoding));
2129: address = value;
2130: if (value)
2131: {
2132: switch (ent->fde_encoding & 0x70)
2133: {
2134: case DW_EH_PE_textrel:
2135: BFD_ASSERT (hdr_info == NULL);
2136: break;
2137: case DW_EH_PE_datarel:
2138: {
2139: switch (abfd->arch_info->arch)
2140: {
2141: case bfd_arch_ia64:
2142: BFD_ASSERT (elf_gp (abfd) != 0);
2143: address += elf_gp (abfd);
2144: break;
2145: default:
1.6 christos 2146: _bfd_error_handler
2147: (_("DW_EH_PE_datarel unspecified"
2148: " for this architecture"));
1.1 christos 2149: /* Fall thru */
2150: case bfd_arch_frv:
2151: case bfd_arch_i386:
2152: BFD_ASSERT (htab->hgot != NULL
2153: && ((htab->hgot->root.type
2154: == bfd_link_hash_defined)
2155: || (htab->hgot->root.type
2156: == bfd_link_hash_defweak)));
2157: address
2158: += (htab->hgot->root.u.def.value
2159: + htab->hgot->root.u.def.section->output_offset
2160: + (htab->hgot->root.u.def.section->output_section
2161: ->vma));
2162: break;
2163: }
2164: }
2165: break;
2166: case DW_EH_PE_pcrel:
2167: value += (bfd_vma) ent->offset - ent->new_offset;
2168: address += (sec->output_section->vma
2169: + sec->output_offset
2170: + ent->offset + 8);
2171: break;
2172: }
2173: if (ent->make_relative)
2174: value -= (sec->output_section->vma
2175: + sec->output_offset
2176: + ent->new_offset + 8);
2177: write_value (abfd, buf, value, width);
2178: }
2179:
2180: start = buf;
2181:
2182: if (hdr_info)
2183: {
2184: /* The address calculation may overflow, giving us a
2185: value greater than 4G on a 32-bit target when
2186: dwarf_vma is 64-bit. */
2187: if (sizeof (address) > 4 && ptr_size == 4)
2188: address &= 0xffffffff;
1.3 christos 2189: hdr_info->u.dwarf.array[hdr_info->array_count].initial_loc
2190: = address;
2191: hdr_info->u.dwarf.array[hdr_info->array_count].range
2192: = read_value (abfd, buf + width, width, FALSE);
2193: hdr_info->u.dwarf.array[hdr_info->array_count++].fde
1.1 christos 2194: = (sec->output_section->vma
2195: + sec->output_offset
2196: + ent->new_offset);
2197: }
2198:
2199: if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel
2200: || cie->u.cie.make_lsda_relative)
2201: {
2202: buf += ent->lsda_offset;
2203: width = get_DW_EH_PE_width (ent->lsda_encoding, ptr_size);
2204: value = read_value (abfd, buf, width,
2205: get_DW_EH_PE_signed (ent->lsda_encoding));
2206: if (value)
2207: {
2208: if ((ent->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
2209: value += (bfd_vma) ent->offset - ent->new_offset;
2210: else if (cie->u.cie.make_lsda_relative)
2211: value -= (sec->output_section->vma
2212: + sec->output_offset
2213: + ent->new_offset + 8 + ent->lsda_offset);
2214: write_value (abfd, buf, value, width);
2215: }
2216: }
2217: else if (ent->add_augmentation_size)
2218: {
2219: /* Skip the PC and length and insert a zero byte for the
2220: augmentation size. */
2221: buf += width * 2;
2222: memmove (buf + 1, buf, end - buf);
2223: *buf = 0;
2224: }
2225:
2226: if (ent->set_loc)
2227: {
2228: /* Adjust DW_CFA_set_loc. */
2229: unsigned int cnt;
2230: bfd_vma new_offset;
2231:
2232: width = get_DW_EH_PE_width (ent->fde_encoding, ptr_size);
2233: new_offset = ent->new_offset + 8
2234: + extra_augmentation_string_bytes (ent)
2235: + extra_augmentation_data_bytes (ent);
2236:
2237: for (cnt = 1; cnt <= ent->set_loc[0]; cnt++)
2238: {
2239: buf = start + ent->set_loc[cnt];
2240:
2241: value = read_value (abfd, buf, width,
2242: get_DW_EH_PE_signed (ent->fde_encoding));
2243: if (!value)
2244: continue;
2245:
2246: if ((ent->fde_encoding & 0x70) == DW_EH_PE_pcrel)
2247: value += (bfd_vma) ent->offset + 8 - new_offset;
2248: if (ent->make_relative)
2249: value -= (sec->output_section->vma
2250: + sec->output_offset
2251: + new_offset + ent->set_loc[cnt]);
2252: write_value (abfd, buf, value, width);
2253: }
2254: }
2255: }
2256: }
2257:
2258: /* FIXME: octets_per_byte. */
2259: return bfd_set_section_contents (abfd, sec->output_section,
2260: contents, (file_ptr) sec->output_offset,
2261: sec->size);
2262: }
2263:
2264: /* Helper function used to sort .eh_frame_hdr search table by increasing
2265: VMA of FDE initial location. */
2266:
2267: static int
2268: vma_compare (const void *a, const void *b)
2269: {
2270: const struct eh_frame_array_ent *p = (const struct eh_frame_array_ent *) a;
2271: const struct eh_frame_array_ent *q = (const struct eh_frame_array_ent *) b;
2272: if (p->initial_loc > q->initial_loc)
2273: return 1;
2274: if (p->initial_loc < q->initial_loc)
2275: return -1;
1.3 christos 2276: if (p->range > q->range)
2277: return 1;
2278: if (p->range < q->range)
2279: return -1;
1.1 christos 2280: return 0;
2281: }
2282:
1.3 christos 2283: /* Reorder .eh_frame_entry sections to match the associated text sections.
2284: This routine is called during the final linking step, just before writing
2285: the contents. At this stage, sections in the eh_frame_hdr_info are already
2286: sorted in order of increasing text section address and so we simply need
2287: to make the .eh_frame_entrys follow that same order. Note that it is
2288: invalid for a linker script to try to force a particular order of
2289: .eh_frame_entry sections. */
2290:
2291: bfd_boolean
2292: _bfd_elf_fixup_eh_frame_hdr (struct bfd_link_info *info)
2293: {
2294: asection *sec = NULL;
2295: asection *osec;
2296: struct eh_frame_hdr_info *hdr_info;
2297: unsigned int i;
2298: bfd_vma offset;
2299: struct bfd_link_order *p;
2300:
2301: hdr_info = &elf_hash_table (info)->eh_info;
2302:
2303: if (hdr_info->hdr_sec == NULL
2304: || info->eh_frame_hdr_type != COMPACT_EH_HDR
2305: || hdr_info->array_count == 0)
2306: return TRUE;
2307:
2308: /* Change section output offsets to be in text section order. */
2309: offset = 8;
2310: osec = hdr_info->u.compact.entries[0]->output_section;
2311: for (i = 0; i < hdr_info->array_count; i++)
2312: {
2313: sec = hdr_info->u.compact.entries[i];
2314: if (sec->output_section != osec)
2315: {
1.6 christos 2316: _bfd_error_handler
2317: (_("invalid output section for .eh_frame_entry: %pA"),
2318: sec->output_section);
1.3 christos 2319: return FALSE;
2320: }
2321: sec->output_offset = offset;
2322: offset += sec->size;
2323: }
2324:
2325:
2326: /* Fix the link_order to match. */
2327: for (p = sec->output_section->map_head.link_order; p != NULL; p = p->next)
2328: {
2329: if (p->type != bfd_indirect_link_order)
2330: abort();
2331:
2332: p->offset = p->u.indirect.section->output_offset;
2333: if (p->next != NULL)
1.6 christos 2334: i--;
1.3 christos 2335: }
2336:
2337: if (i != 0)
2338: {
1.6 christos 2339: _bfd_error_handler
2340: (_("invalid contents in %pA section"), osec);
1.3 christos 2341: return FALSE;
2342: }
2343:
2344: return TRUE;
2345: }
2346:
2347: /* The .eh_frame_hdr format for Compact EH frames:
2348: ubyte version (2)
2349: ubyte eh_ref_enc (DW_EH_PE_* encoding of typinfo references)
2350: uint32_t count (Number of entries in table)
2351: [array from .eh_frame_entry sections] */
2352:
2353: static bfd_boolean
2354: write_compact_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2355: {
2356: struct elf_link_hash_table *htab;
2357: struct eh_frame_hdr_info *hdr_info;
2358: asection *sec;
2359: const struct elf_backend_data *bed;
2360: bfd_vma count;
2361: bfd_byte contents[8];
2362: unsigned int i;
2363:
2364: htab = elf_hash_table (info);
2365: hdr_info = &htab->eh_info;
2366: sec = hdr_info->hdr_sec;
2367:
2368: if (sec->size != 8)
2369: abort();
2370:
2371: for (i = 0; i < sizeof (contents); i++)
2372: contents[i] = 0;
2373:
2374: contents[0] = COMPACT_EH_HDR;
2375: bed = get_elf_backend_data (abfd);
2376:
2377: BFD_ASSERT (bed->compact_eh_encoding);
2378: contents[1] = (*bed->compact_eh_encoding) (info);
2379:
2380: count = (sec->output_section->size - 8) / 8;
2381: bfd_put_32 (abfd, count, contents + 4);
2382: return bfd_set_section_contents (abfd, sec->output_section, contents,
2383: (file_ptr) sec->output_offset, sec->size);
2384: }
2385:
2386: /* The .eh_frame_hdr format for DWARF frames:
2387:
1.1 christos 2388: ubyte version (currently 1)
1.6 christos 2389: ubyte eh_frame_ptr_enc (DW_EH_PE_* encoding of pointer to start of
1.1 christos 2390: .eh_frame section)
2391: ubyte fde_count_enc (DW_EH_PE_* encoding of total FDE count
2392: number (or DW_EH_PE_omit if there is no
2393: binary search table computed))
2394: ubyte table_enc (DW_EH_PE_* encoding of binary search table,
2395: or DW_EH_PE_omit if not present.
2396: DW_EH_PE_datarel is using address of
2397: .eh_frame_hdr section start as base)
2398: [encoded] eh_frame_ptr (pointer to start of .eh_frame section)
2399: optionally followed by:
2400: [encoded] fde_count (total number of FDEs in .eh_frame section)
2401: fde_count x [encoded] initial_loc, fde
2402: (array of encoded pairs containing
2403: FDE initial_location field and FDE address,
2404: sorted by increasing initial_loc). */
2405:
1.3 christos 2406: static bfd_boolean
2407: write_dwarf_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
1.1 christos 2408: {
2409: struct elf_link_hash_table *htab;
2410: struct eh_frame_hdr_info *hdr_info;
2411: asection *sec;
1.3 christos 2412: bfd_boolean retval = TRUE;
2413:
2414: htab = elf_hash_table (info);
2415: hdr_info = &htab->eh_info;
2416: sec = hdr_info->hdr_sec;
1.1 christos 2417: bfd_byte *contents;
2418: asection *eh_frame_sec;
2419: bfd_size_type size;
2420: bfd_vma encoded_eh_frame;
2421:
2422: size = EH_FRAME_HDR_SIZE;
1.3 christos 2423: if (hdr_info->u.dwarf.array
2424: && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
2425: size += 4 + hdr_info->u.dwarf.fde_count * 8;
1.1 christos 2426: contents = (bfd_byte *) bfd_malloc (size);
2427: if (contents == NULL)
2428: return FALSE;
2429:
2430: eh_frame_sec = bfd_get_section_by_name (abfd, ".eh_frame");
2431: if (eh_frame_sec == NULL)
2432: {
2433: free (contents);
2434: return FALSE;
2435: }
2436:
2437: memset (contents, 0, EH_FRAME_HDR_SIZE);
1.3 christos 2438: /* Version. */
2439: contents[0] = 1;
2440: /* .eh_frame offset. */
1.1 christos 2441: contents[1] = get_elf_backend_data (abfd)->elf_backend_encode_eh_address
1.3 christos 2442: (abfd, info, eh_frame_sec, 0, sec, 4, &encoded_eh_frame);
1.1 christos 2443:
1.3 christos 2444: if (hdr_info->u.dwarf.array
2445: && hdr_info->array_count == hdr_info->u.dwarf.fde_count)
1.1 christos 2446: {
1.3 christos 2447: /* FDE count encoding. */
2448: contents[2] = DW_EH_PE_udata4;
2449: /* Search table encoding. */
2450: contents[3] = DW_EH_PE_datarel | DW_EH_PE_sdata4;
1.1 christos 2451: }
2452: else
2453: {
2454: contents[2] = DW_EH_PE_omit;
2455: contents[3] = DW_EH_PE_omit;
2456: }
2457: bfd_put_32 (abfd, encoded_eh_frame, contents + 4);
2458:
2459: if (contents[2] != DW_EH_PE_omit)
2460: {
2461: unsigned int i;
1.3 christos 2462: bfd_boolean overlap, overflow;
1.1 christos 2463:
1.3 christos 2464: bfd_put_32 (abfd, hdr_info->u.dwarf.fde_count,
2465: contents + EH_FRAME_HDR_SIZE);
2466: qsort (hdr_info->u.dwarf.array, hdr_info->u.dwarf.fde_count,
2467: sizeof (*hdr_info->u.dwarf.array), vma_compare);
2468: overlap = FALSE;
2469: overflow = FALSE;
2470: for (i = 0; i < hdr_info->u.dwarf.fde_count; i++)
2471: {
2472: bfd_vma val;
2473:
2474: val = hdr_info->u.dwarf.array[i].initial_loc
2475: - sec->output_section->vma;
2476: val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2477: if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2478: && (hdr_info->u.dwarf.array[i].initial_loc
2479: != sec->output_section->vma + val))
2480: overflow = TRUE;
2481: bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 4);
2482: val = hdr_info->u.dwarf.array[i].fde - sec->output_section->vma;
2483: val = ((val & 0xffffffff) ^ 0x80000000) - 0x80000000;
2484: if (elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64
2485: && (hdr_info->u.dwarf.array[i].fde
2486: != sec->output_section->vma + val))
2487: overflow = TRUE;
2488: bfd_put_32 (abfd, val, contents + EH_FRAME_HDR_SIZE + i * 8 + 8);
2489: if (i != 0
2490: && (hdr_info->u.dwarf.array[i].initial_loc
2491: < (hdr_info->u.dwarf.array[i - 1].initial_loc
2492: + hdr_info->u.dwarf.array[i - 1].range)))
2493: overlap = TRUE;
2494: }
2495: if (overflow)
1.6 christos 2496: _bfd_error_handler (_(".eh_frame_hdr entry overflow"));
1.3 christos 2497: if (overlap)
1.6 christos 2498: _bfd_error_handler (_(".eh_frame_hdr refers to overlapping FDEs"));
1.3 christos 2499: if (overflow || overlap)
1.1 christos 2500: {
1.3 christos 2501: bfd_set_error (bfd_error_bad_value);
2502: retval = FALSE;
1.1 christos 2503: }
2504: }
2505:
2506: /* FIXME: octets_per_byte. */
1.3 christos 2507: if (!bfd_set_section_contents (abfd, sec->output_section, contents,
2508: (file_ptr) sec->output_offset,
2509: sec->size))
2510: retval = FALSE;
1.1 christos 2511: free (contents);
1.3 christos 2512:
2513: if (hdr_info->u.dwarf.array != NULL)
2514: free (hdr_info->u.dwarf.array);
1.1 christos 2515: return retval;
2516: }
2517:
1.3 christos 2518: /* Write out .eh_frame_hdr section. This must be called after
2519: _bfd_elf_write_section_eh_frame has been called on all input
2520: .eh_frame sections. */
2521:
2522: bfd_boolean
2523: _bfd_elf_write_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
2524: {
2525: struct elf_link_hash_table *htab;
2526: struct eh_frame_hdr_info *hdr_info;
2527: asection *sec;
2528:
2529: htab = elf_hash_table (info);
2530: hdr_info = &htab->eh_info;
2531: sec = hdr_info->hdr_sec;
2532:
2533: if (info->eh_frame_hdr_type == 0 || sec == NULL)
2534: return TRUE;
2535:
2536: if (info->eh_frame_hdr_type == COMPACT_EH_HDR)
2537: return write_compact_eh_frame_hdr (abfd, info);
2538: else
2539: return write_dwarf_eh_frame_hdr (abfd, info);
2540: }
2541:
1.1 christos 2542: /* Return the width of FDE addresses. This is the default implementation. */
2543:
2544: unsigned int
1.6 christos 2545: _bfd_elf_eh_frame_address_size (bfd *abfd, const asection *sec ATTRIBUTE_UNUSED)
1.1 christos 2546: {
2547: return elf_elfheader (abfd)->e_ident[EI_CLASS] == ELFCLASS64 ? 8 : 4;
2548: }
2549:
2550: /* Decide whether we can use a PC-relative encoding within the given
2551: EH frame section. This is the default implementation. */
2552:
2553: bfd_boolean
2554: _bfd_elf_can_make_relative (bfd *input_bfd ATTRIBUTE_UNUSED,
2555: struct bfd_link_info *info ATTRIBUTE_UNUSED,
2556: asection *eh_frame_section ATTRIBUTE_UNUSED)
2557: {
2558: return TRUE;
2559: }
2560:
2561: /* Select an encoding for the given address. Preference is given to
2562: PC-relative addressing modes. */
2563:
2564: bfd_byte
2565: _bfd_elf_encode_eh_address (bfd *abfd ATTRIBUTE_UNUSED,
2566: struct bfd_link_info *info ATTRIBUTE_UNUSED,
2567: asection *osec, bfd_vma offset,
2568: asection *loc_sec, bfd_vma loc_offset,
2569: bfd_vma *encoded)
2570: {
2571: *encoded = osec->vma + offset -
2572: (loc_sec->output_section->vma + loc_sec->output_offset + loc_offset);
2573: return DW_EH_PE_pcrel | DW_EH_PE_sdata4;
2574: }
CVSweb <webmaster@jp.NetBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to elf-eh-frame.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [cvs.NetBSD.org] / src / external / gpl3 / binutils.old / dist / bfd