projects / deliverable / binutils-gdb.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
* doc/Makefile.am (config.texi): Set top_srcdir.
[deliverable/binutils-gdb.git] / gas / dw2gencfi.c
... / ...
CommitLineData
1/* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright 2003, 2004, 2005 Free Software Foundation, Inc.
3 Contributed by Michal Ludvig <mludvig@suse.cz>
4
5 This file is part of GAS, the GNU Assembler.
6
7 GAS 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, or (at your option)
10 any later version.
11
12 GAS 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 GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
20 02110-1301, USA. */
21
22#include "as.h"
23#include "dw2gencfi.h"
24
25
26/* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
27 of the CIE. Default to 1 if not otherwise specified. */
28#ifndef DWARF2_LINE_MIN_INSN_LENGTH
29# define DWARF2_LINE_MIN_INSN_LENGTH 1
30#endif
31
32/* If TARGET_USE_CFIPOP is defined, it is required that the target
33 provide the following definitions. Otherwise provide them to
34 allow compilation to continue. */
35#ifndef TARGET_USE_CFIPOP
36# ifndef DWARF2_DEFAULT_RETURN_COLUMN
37# define DWARF2_DEFAULT_RETURN_COLUMN 0
38# endif
39# ifndef DWARF2_CIE_DATA_ALIGNMENT
40# define DWARF2_CIE_DATA_ALIGNMENT 1
41# endif
42#endif
43
44#ifndef EH_FRAME_ALIGNMENT
45# define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
46#endif
47
48#ifndef tc_cfi_frame_initial_instructions
49# define tc_cfi_frame_initial_instructions() ((void)0)
50#endif
51
52
53struct cfi_insn_data
54{
55 struct cfi_insn_data *next;
56 int insn;
57 union {
58 struct {
59 unsigned reg;
60 offsetT offset;
61 } ri;
62
63 struct {
64 unsigned reg1;
65 unsigned reg2;
66 } rr;
67
68 unsigned r;
69 offsetT i;
70
71 struct {
72 symbolS *lab1;
73 symbolS *lab2;
74 } ll;
75
76 struct cfi_escape_data {
77 struct cfi_escape_data *next;
78 expressionS exp;
79 } *esc;
80 } u;
81};
82
83struct fde_entry
84{
85 struct fde_entry *next;
86 symbolS *start_address;
87 symbolS *end_address;
88 struct cfi_insn_data *data;
89 struct cfi_insn_data **last;
90 unsigned int return_column;
91};
92
93struct cie_entry
94{
95 struct cie_entry *next;
96 symbolS *start_address;
97 unsigned int return_column;
98 struct cfi_insn_data *first, *last;
99};
100
101
102/* Current open FDE entry. */
103static struct fde_entry *cur_fde_data;
104static symbolS *last_address;
105static offsetT cur_cfa_offset;
106
107/* List of FDE entries. */
108static struct fde_entry *all_fde_data;
109static struct fde_entry **last_fde_data = &all_fde_data;
110
111/* List of CIEs so that they could be reused. */
112static struct cie_entry *cie_root;
113
114/* Stack of old CFI data, for save/restore. */
115struct cfa_save_data
116{
117 struct cfa_save_data *next;
118 offsetT cfa_offset;
119};
120
121static struct cfa_save_data *cfa_save_stack;
122\f
123/* Construct a new FDE structure and add it to the end of the fde list. */
124
125static struct fde_entry *
126alloc_fde_entry (void)
127{
128 struct fde_entry *fde = xcalloc (1, sizeof (struct fde_entry));
129
130 cur_fde_data = fde;
131 *last_fde_data = fde;
132 last_fde_data = &fde->next;
133
134 fde->last = &fde->data;
135 fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
136
137 return fde;
138}
139
140/* The following functions are available for a backend to construct its
141 own unwind information, usually from legacy unwind directives. */
142
143/* Construct a new INSN structure and add it to the end of the insn list
144 for the currently active FDE. */
145
146static struct cfi_insn_data *
147alloc_cfi_insn_data (void)
148{
149 struct cfi_insn_data *insn = xcalloc (1, sizeof (struct cfi_insn_data));
150
151 *cur_fde_data->last = insn;
152 cur_fde_data->last = &insn->next;
153
154 return insn;
155}
156
157/* Construct a new FDE structure that begins at LABEL. */
158
159void
160cfi_new_fde (symbolS *label)
161{
162 struct fde_entry *fde = alloc_fde_entry ();
163 fde->start_address = label;
164 last_address = label;
165}
166
167/* End the currently open FDE. */
168
169void
170cfi_end_fde (symbolS *label)
171{
172 cur_fde_data->end_address = label;
173 cur_fde_data = NULL;
174}
175
176/* Set the return column for the current FDE. */
177
178void
179cfi_set_return_column (unsigned regno)
180{
181 cur_fde_data->return_column = regno;
182}
183
184/* Universal functions to store new instructions. */
185
186static void
187cfi_add_CFA_insn(int insn)
188{
189 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
190
191 insn_ptr->insn = insn;
192}
193
194static void
195cfi_add_CFA_insn_reg (int insn, unsigned regno)
196{
197 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
198
199 insn_ptr->insn = insn;
200 insn_ptr->u.r = regno;
201}
202
203static void
204cfi_add_CFA_insn_offset (int insn, offsetT offset)
205{
206 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
207
208 insn_ptr->insn = insn;
209 insn_ptr->u.i = offset;
210}
211
212static void
213cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
214{
215 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
216
217 insn_ptr->insn = insn;
218 insn_ptr->u.rr.reg1 = reg1;
219 insn_ptr->u.rr.reg2 = reg2;
220}
221
222static void
223cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
224{
225 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
226
227 insn_ptr->insn = insn;
228 insn_ptr->u.ri.reg = regno;
229 insn_ptr->u.ri.offset = offset;
230}
231
232/* Add a CFI insn to advance the PC from the last address to LABEL. */
233
234void
235cfi_add_advance_loc (symbolS *label)
236{
237 struct cfi_insn_data *insn = alloc_cfi_insn_data ();
238
239 insn->insn = DW_CFA_advance_loc;
240 insn->u.ll.lab1 = last_address;
241 insn->u.ll.lab2 = label;
242
243 last_address = label;
244}
245
246/* Add a DW_CFA_offset record to the CFI data. */
247
248void
249cfi_add_CFA_offset (unsigned regno, offsetT offset)
250{
251 unsigned int abs_data_align;
252
253 cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
254
255 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
256 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
257 if (offset % abs_data_align)
258 as_bad (_("register save offset not a multiple of %u"), abs_data_align);
259}
260
261/* Add a DW_CFA_def_cfa record to the CFI data. */
262
263void
264cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
265{
266 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
267 cur_cfa_offset = offset;
268}
269
270/* Add a DW_CFA_register record to the CFI data. */
271
272void
273cfi_add_CFA_register (unsigned reg1, unsigned reg2)
274{
275 cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
276}
277
278/* Add a DW_CFA_def_cfa_register record to the CFI data. */
279
280void
281cfi_add_CFA_def_cfa_register (unsigned regno)
282{
283 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
284}
285
286/* Add a DW_CFA_def_cfa_offset record to the CFI data. */
287
288void
289cfi_add_CFA_def_cfa_offset (offsetT offset)
290{
291 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
292 cur_cfa_offset = offset;
293}
294
295void
296cfi_add_CFA_restore (unsigned regno)
297{
298 cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
299}
300
301void
302cfi_add_CFA_undefined (unsigned regno)
303{
304 cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
305}
306
307void
308cfi_add_CFA_same_value (unsigned regno)
309{
310 cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
311}
312
313void
314cfi_add_CFA_remember_state (void)
315{
316 struct cfa_save_data *p;
317
318 cfi_add_CFA_insn (DW_CFA_remember_state);
319
320 p = xmalloc (sizeof (*p));
321 p->cfa_offset = cur_cfa_offset;
322 p->next = cfa_save_stack;
323 cfa_save_stack = p;
324}
325
326void
327cfi_add_CFA_restore_state (void)
328{
329 struct cfa_save_data *p;
330
331 cfi_add_CFA_insn (DW_CFA_restore_state);
332
333 p = cfa_save_stack;
334 if (p)
335 {
336 cur_cfa_offset = p->cfa_offset;
337 cfa_save_stack = p->next;
338 free (p);
339 }
340 else
341 as_bad (_("CFI state restore without previous remember"));
342}
343
344\f
345/* Parse CFI assembler directives. */
346
347static void dot_cfi (int);
348static void dot_cfi_escape (int);
349static void dot_cfi_startproc (int);
350static void dot_cfi_endproc (int);
351
352/* Fake CFI type; outside the byte range of any real CFI insn. */
353#define CFI_adjust_cfa_offset 0x100
354#define CFI_return_column 0x101
355#define CFI_rel_offset 0x102
356#define CFI_escape 0x103
357
358const pseudo_typeS cfi_pseudo_table[] =
359 {
360 { "cfi_startproc", dot_cfi_startproc, 0 },
361 { "cfi_endproc", dot_cfi_endproc, 0 },
362 { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
363 { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
364 { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
365 { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
366 { "cfi_offset", dot_cfi, DW_CFA_offset },
367 { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
368 { "cfi_register", dot_cfi, DW_CFA_register },
369 { "cfi_return_column", dot_cfi, CFI_return_column },
370 { "cfi_restore", dot_cfi, DW_CFA_restore },
371 { "cfi_undefined", dot_cfi, DW_CFA_undefined },
372 { "cfi_same_value", dot_cfi, DW_CFA_same_value },
373 { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
374 { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
375 { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
376 { "cfi_escape", dot_cfi_escape, 0 },
377 { NULL, NULL, 0 }
378 };
379
380static void
381cfi_parse_separator (void)
382{
383 SKIP_WHITESPACE ();
384 if (*input_line_pointer == ',')
385 input_line_pointer++;
386 else
387 as_bad (_("missing separator"));
388}
389
390static unsigned
391cfi_parse_reg (void)
392{
393 int regno;
394 expressionS exp;
395
396#ifdef tc_regname_to_dw2regnum
397 SKIP_WHITESPACE ();
398 if (is_name_beginner (*input_line_pointer)
399 || (*input_line_pointer == '%'
400 && is_name_beginner (*++input_line_pointer)))
401 {
402 char *name, c;
403
404 name = input_line_pointer;
405 c = get_symbol_end ();
406
407 if ((regno = tc_regname_to_dw2regnum (name)) < 0)
408 {
409 as_bad (_("bad register expression"));
410 regno = 0;
411 }
412
413 *input_line_pointer = c;
414 return regno;
415 }
416#endif
417
418 expression (&exp);
419 switch (exp.X_op)
420 {
421 case O_register:
422 case O_constant:
423 regno = exp.X_add_number;
424 break;
425
426 default:
427 as_bad (_("bad register expression"));
428 regno = 0;
429 break;
430 }
431
432 return regno;
433}
434
435static offsetT
436cfi_parse_const (void)
437{
438 return get_absolute_expression ();
439}
440
441static void
442dot_cfi (int arg)
443{
444 offsetT offset;
445 unsigned reg1, reg2;
446
447 if (!cur_fde_data)
448 {
449 as_bad (_("CFI instruction used without previous .cfi_startproc"));
450 ignore_rest_of_line ();
451 return;
452 }
453
454 /* If the last address was not at the current PC, advance to current. */
455 if (symbol_get_frag (last_address) != frag_now
456 || S_GET_VALUE (last_address) != frag_now_fix ())
457 cfi_add_advance_loc (symbol_temp_new_now ());
458
459 switch (arg)
460 {
461 case DW_CFA_offset:
462 reg1 = cfi_parse_reg ();
463 cfi_parse_separator ();
464 offset = cfi_parse_const ();
465 cfi_add_CFA_offset (reg1, offset);
466 break;
467
468 case CFI_rel_offset:
469 reg1 = cfi_parse_reg ();
470 cfi_parse_separator ();
471 offset = cfi_parse_const ();
472 cfi_add_CFA_offset (reg1, offset - cur_cfa_offset);
473 break;
474
475 case DW_CFA_def_cfa:
476 reg1 = cfi_parse_reg ();
477 cfi_parse_separator ();
478 offset = cfi_parse_const ();
479 cfi_add_CFA_def_cfa (reg1, offset);
480 break;
481
482 case DW_CFA_register:
483 reg1 = cfi_parse_reg ();
484 cfi_parse_separator ();
485 reg2 = cfi_parse_reg ();
486 cfi_add_CFA_register (reg1, reg2);
487 break;
488
489 case DW_CFA_def_cfa_register:
490 reg1 = cfi_parse_reg ();
491 cfi_add_CFA_def_cfa_register (reg1);
492 break;
493
494 case DW_CFA_def_cfa_offset:
495 offset = cfi_parse_const ();
496 cfi_add_CFA_def_cfa_offset (offset);
497 break;
498
499 case CFI_adjust_cfa_offset:
500 offset = cfi_parse_const ();
501 cfi_add_CFA_def_cfa_offset (cur_cfa_offset + offset);
502 break;
503
504 case DW_CFA_restore:
505 reg1 = cfi_parse_reg ();
506 cfi_add_CFA_restore (reg1);
507 break;
508
509 case DW_CFA_undefined:
510 reg1 = cfi_parse_reg ();
511 cfi_add_CFA_undefined (reg1);
512 break;
513
514 case DW_CFA_same_value:
515 reg1 = cfi_parse_reg ();
516 cfi_add_CFA_same_value (reg1);
517 break;
518
519 case CFI_return_column:
520 reg1 = cfi_parse_reg ();
521 cfi_set_return_column (reg1);
522 break;
523
524 case DW_CFA_remember_state:
525 cfi_add_CFA_remember_state ();
526 break;
527
528 case DW_CFA_restore_state:
529 cfi_add_CFA_restore_state ();
530 break;
531
532 case DW_CFA_GNU_window_save:
533 cfi_add_CFA_insn (DW_CFA_GNU_window_save);
534 break;
535
536 default:
537 abort ();
538 }
539
540 demand_empty_rest_of_line ();
541}
542
543static void
544dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
545{
546 struct cfi_escape_data *head, **tail, *e;
547 struct cfi_insn_data *insn;
548
549 if (!cur_fde_data)
550 {
551 as_bad (_("CFI instruction used without previous .cfi_startproc"));
552 ignore_rest_of_line ();
553 return;
554 }
555
556 /* If the last address was not at the current PC, advance to current. */
557 if (symbol_get_frag (last_address) != frag_now
558 || S_GET_VALUE (last_address) != frag_now_fix ())
559 cfi_add_advance_loc (symbol_temp_new_now ());
560
561 tail = &head;
562 do
563 {
564 e = xmalloc (sizeof (*e));
565 do_parse_cons_expression (&e->exp, 1);
566 *tail = e;
567 tail = &e->next;
568 }
569 while (*input_line_pointer++ == ',');
570 *tail = NULL;
571
572 insn = alloc_cfi_insn_data ();
573 insn->insn = CFI_escape;
574 insn->u.esc = head;
575
576 --input_line_pointer;
577 demand_empty_rest_of_line ();
578}
579
580static void
581dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
582{
583 int simple = 0;
584
585 if (cur_fde_data)
586 {
587 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
588 ignore_rest_of_line ();
589 return;
590 }
591
592 cfi_new_fde (symbol_temp_new_now ());
593
594 SKIP_WHITESPACE ();
595 if (is_name_beginner (*input_line_pointer))
596 {
597 char *name, c;
598
599 name = input_line_pointer;
600 c = get_symbol_end ();
601
602 if (strcmp (name, "simple") == 0)
603 {
604 simple = 1;
605 *input_line_pointer = c;
606 }
607 else
608 input_line_pointer = name;
609 }
610 demand_empty_rest_of_line ();
611
612 cur_cfa_offset = 0;
613 if (!simple)
614 tc_cfi_frame_initial_instructions ();
615}
616
617static void
618dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
619{
620 if (! cur_fde_data)
621 {
622 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
623 ignore_rest_of_line ();
624 return;
625 }
626
627 cfi_end_fde (symbol_temp_new_now ());
628
629 demand_empty_rest_of_line ();
630}
631
632\f
633/* Emit a single byte into the current segment. */
634
635static inline void
636out_one (int byte)
637{
638 FRAG_APPEND_1_CHAR (byte);
639}
640
641/* Emit a two-byte word into the current segment. */
642
643static inline void
644out_two (int data)
645{
646 md_number_to_chars (frag_more (2), data, 2);
647}
648
649/* Emit a four byte word into the current segment. */
650
651static inline void
652out_four (int data)
653{
654 md_number_to_chars (frag_more (4), data, 4);
655}
656
657/* Emit an unsigned "little-endian base 128" number. */
658
659static void
660out_uleb128 (addressT value)
661{
662 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
663}
664
665/* Emit an unsigned "little-endian base 128" number. */
666
667static void
668out_sleb128 (offsetT value)
669{
670 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
671}
672
673static void
674output_cfi_insn (struct cfi_insn_data *insn)
675{
676 offsetT offset;
677 unsigned int regno;
678
679 switch (insn->insn)
680 {
681 case DW_CFA_advance_loc:
682 {
683 symbolS *from = insn->u.ll.lab1;
684 symbolS *to = insn->u.ll.lab2;
685
686 if (symbol_get_frag (to) == symbol_get_frag (from))
687 {
688 addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
689 addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
690
691 if (scaled <= 0x3F)
692 out_one (DW_CFA_advance_loc + scaled);
693 else if (delta <= 0xFF)
694 {
695 out_one (DW_CFA_advance_loc1);
696 out_one (delta);
697 }
698 else if (delta <= 0xFFFF)
699 {
700 out_one (DW_CFA_advance_loc2);
701 out_two (delta);
702 }
703 else
704 {
705 out_one (DW_CFA_advance_loc4);
706 out_four (delta);
707 }
708 }
709 else
710 {
711 expressionS exp;
712
713 exp.X_op = O_subtract;
714 exp.X_add_symbol = to;
715 exp.X_op_symbol = from;
716 exp.X_add_number = 0;
717
718 /* The code in ehopt.c expects that one byte of the encoding
719 is already allocated to the frag. This comes from the way
720 that it scans the .eh_frame section looking first for the
721 .byte DW_CFA_advance_loc4. */
722 frag_more (1);
723
724 frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
725 make_expr_symbol (&exp), frag_now_fix () - 1,
726 (char *) frag_now);
727 }
728 }
729 break;
730
731 case DW_CFA_def_cfa:
732 offset = insn->u.ri.offset;
733 if (offset < 0)
734 {
735 out_one (DW_CFA_def_cfa_sf);
736 out_uleb128 (insn->u.ri.reg);
737 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
738 }
739 else
740 {
741 out_one (DW_CFA_def_cfa);
742 out_uleb128 (insn->u.ri.reg);
743 out_uleb128 (offset);
744 }
745 break;
746
747 case DW_CFA_def_cfa_register:
748 case DW_CFA_undefined:
749 case DW_CFA_same_value:
750 out_one (insn->insn);
751 out_uleb128 (insn->u.r);
752 break;
753
754 case DW_CFA_def_cfa_offset:
755 offset = insn->u.i;
756 if (offset < 0)
757 {
758 out_one (DW_CFA_def_cfa_offset_sf);
759 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
760 }
761 else
762 {
763 out_one (DW_CFA_def_cfa_offset);
764 out_uleb128 (offset);
765 }
766 break;
767
768 case DW_CFA_restore:
769 regno = insn->u.r;
770 if (regno <= 0x3F)
771 {
772 out_one (DW_CFA_restore + regno);
773 }
774 else
775 {
776 out_one (DW_CFA_restore_extended);
777 out_uleb128 (regno);
778 }
779 break;
780
781 case DW_CFA_offset:
782 regno = insn->u.ri.reg;
783 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
784 if (offset < 0)
785 {
786 out_one (DW_CFA_offset_extended_sf);
787 out_uleb128 (regno);
788 out_sleb128 (offset);
789 }
790 else if (regno <= 0x3F)
791 {
792 out_one (DW_CFA_offset + regno);
793 out_uleb128 (offset);
794 }
795 else
796 {
797 out_one (DW_CFA_offset_extended);
798 out_uleb128 (regno);
799 out_uleb128 (offset);
800 }
801 break;
802
803 case DW_CFA_register:
804 out_one (DW_CFA_register);
805 out_uleb128 (insn->u.rr.reg1);
806 out_uleb128 (insn->u.rr.reg2);
807 break;
808
809 case DW_CFA_remember_state:
810 case DW_CFA_restore_state:
811 out_one (insn->insn);
812 break;
813
814 case DW_CFA_GNU_window_save:
815 out_one (DW_CFA_GNU_window_save);
816 break;
817
818 case CFI_escape:
819 {
820 struct cfi_escape_data *e;
821 for (e = insn->u.esc; e ; e = e->next)
822 emit_expr (&e->exp, 1);
823 break;
824 }
825
826 default:
827 abort ();
828 }
829}
830
831static void
832output_cie (struct cie_entry *cie)
833{
834 symbolS *after_size_address, *end_address;
835 expressionS exp;
836 struct cfi_insn_data *i;
837
838 cie->start_address = symbol_temp_new_now ();
839 after_size_address = symbol_temp_make ();
840 end_address = symbol_temp_make ();
841
842 exp.X_op = O_subtract;
843 exp.X_add_symbol = end_address;
844 exp.X_op_symbol = after_size_address;
845 exp.X_add_number = 0;
846
847 emit_expr (&exp, 4); /* Length. */
848 symbol_set_value_now (after_size_address);
849 out_four (0); /* CIE id. */
850 out_one (DW_CIE_VERSION); /* Version. */
851 out_one ('z'); /* Augmentation. */
852 out_one ('R');
853 out_one (0);
854 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */
855 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */
856 if (DW_CIE_VERSION == 1) /* Return column. */
857 out_one (cie->return_column);
858 else
859 out_uleb128 (cie->return_column);
860 out_uleb128 (1); /* Augmentation size. */
861#if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
862 out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
863#else
864 out_one (DW_EH_PE_sdata4);
865#endif
866
867 if (cie->first)
868 for (i = cie->first; i != cie->last; i = i->next)
869 output_cfi_insn (i);
870
871 frag_align (2, DW_CFA_nop, 0);
872 symbol_set_value_now (end_address);
873}
874
875static void
876output_fde (struct fde_entry *fde, struct cie_entry *cie,
877 struct cfi_insn_data *first, int align)
878{
879 symbolS *after_size_address, *end_address;
880 expressionS exp;
881
882 after_size_address = symbol_temp_make ();
883 end_address = symbol_temp_make ();
884
885 exp.X_op = O_subtract;
886 exp.X_add_symbol = end_address;
887 exp.X_op_symbol = after_size_address;
888 exp.X_add_number = 0;
889 emit_expr (&exp, 4); /* Length. */
890 symbol_set_value_now (after_size_address);
891
892 exp.X_add_symbol = after_size_address;
893 exp.X_op_symbol = cie->start_address;
894 emit_expr (&exp, 4); /* CIE offset. */
895
896#ifdef DIFF_EXPR_OK
897 exp.X_add_symbol = fde->start_address;
898 exp.X_op_symbol = symbol_temp_new_now ();
899 emit_expr (&exp, 4); /* Code offset. */
900#else
901 exp.X_op = O_symbol;
902 exp.X_add_symbol = fde->start_address;
903 exp.X_op_symbol = NULL;
904#ifdef tc_cfi_emit_pcrel_expr
905 tc_cfi_emit_pcrel_expr (&exp, 4); /* Code offset. */
906#else
907 emit_expr (&exp, 4); /* Code offset. */
908#endif
909 exp.X_op = O_subtract;
910#endif
911
912 exp.X_add_symbol = fde->end_address;
913 exp.X_op_symbol = fde->start_address; /* Code length. */
914 emit_expr (&exp, 4);
915
916 out_uleb128 (0); /* Augmentation size. */
917
918 for (; first; first = first->next)
919 output_cfi_insn (first);
920
921 frag_align (align, DW_CFA_nop, 0);
922 symbol_set_value_now (end_address);
923}
924
925static struct cie_entry *
926select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
927{
928 struct cfi_insn_data *i, *j;
929 struct cie_entry *cie;
930
931 for (cie = cie_root; cie; cie = cie->next)
932 {
933 if (cie->return_column != fde->return_column)
934 continue;
935 for (i = cie->first, j = fde->data;
936 i != cie->last && j != NULL;
937 i = i->next, j = j->next)
938 {
939 if (i->insn != j->insn)
940 goto fail;
941 switch (i->insn)
942 {
943 case DW_CFA_advance_loc:
944 case DW_CFA_remember_state:
945 /* We reached the first advance/remember in the FDE,
946 but did not reach the end of the CIE list. */
947 goto fail;
948
949 case DW_CFA_offset:
950 case DW_CFA_def_cfa:
951 if (i->u.ri.reg != j->u.ri.reg)
952 goto fail;
953 if (i->u.ri.offset != j->u.ri.offset)
954 goto fail;
955 break;
956
957 case DW_CFA_register:
958 if (i->u.rr.reg1 != j->u.rr.reg1)
959 goto fail;
960 if (i->u.rr.reg2 != j->u.rr.reg2)
961 goto fail;
962 break;
963
964 case DW_CFA_def_cfa_register:
965 case DW_CFA_restore:
966 case DW_CFA_undefined:
967 case DW_CFA_same_value:
968 if (i->u.r != j->u.r)
969 goto fail;
970 break;
971
972 case DW_CFA_def_cfa_offset:
973 if (i->u.i != j->u.i)
974 goto fail;
975 break;
976
977 case CFI_escape:
978 /* Don't bother matching these for now. */
979 goto fail;
980
981 default:
982 abort ();
983 }
984 }
985
986 /* Success if we reached the end of the CIE list, and we've either
987 run out of FDE entries or we've encountered an advance,
988 remember, or escape. */
989 if (i == cie->last
990 && (!j
991 || j->insn == DW_CFA_advance_loc
992 || j->insn == DW_CFA_remember_state
993 || j->insn == CFI_escape))
994 {
995 *pfirst = j;
996 return cie;
997 }
998
999 fail:;
1000 }
1001
1002 cie = xmalloc (sizeof (struct cie_entry));
1003 cie->next = cie_root;
1004 cie_root = cie;
1005 cie->return_column = fde->return_column;
1006 cie->first = fde->data;
1007
1008 for (i = cie->first; i ; i = i->next)
1009 if (i->insn == DW_CFA_advance_loc
1010 || i->insn == DW_CFA_remember_state
1011 || i->insn == CFI_escape)
1012 break;
1013
1014 cie->last = i;
1015 *pfirst = i;
1016
1017 output_cie (cie);
1018
1019 return cie;
1020}
1021
1022void
1023cfi_finish (void)
1024{
1025 segT cfi_seg;
1026 struct fde_entry *fde;
1027 int save_flag_traditional_format;
1028
1029 if (cur_fde_data)
1030 {
1031 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1032 cur_fde_data->end_address = cur_fde_data->start_address;
1033 }
1034
1035 if (all_fde_data == 0)
1036 return;
1037
1038 /* Open .eh_frame section. */
1039 cfi_seg = subseg_new (".eh_frame", 0);
1040 bfd_set_section_flags (stdoutput, cfi_seg,
1041 SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1042 subseg_set (cfi_seg, 0);
1043 record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1044
1045 /* Make sure check_eh_frame doesn't do anything with our output. */
1046 save_flag_traditional_format = flag_traditional_format;
1047 flag_traditional_format = 1;
1048
1049 for (fde = all_fde_data; fde ; fde = fde->next)
1050 {
1051 struct cfi_insn_data *first;
1052 struct cie_entry *cie;
1053
1054 cie = select_cie_for_fde (fde, &first);
1055 output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1056 }
1057
1058 flag_traditional_format = save_flag_traditional_format;
1059}
GDB Binutils - Deliverables
This page took 0.025409 seconds and 4 git commands to generate.