daily update
[binutils.git] / gas / dw2gencfi.c
blobbfa5d5cf45a6f74d0815a0d80810b41bed0b284c
1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
3 Contributed by Michal Ludvig <mludvig@suse.cz>
5 This file is part of GAS, the GNU Assembler.
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.
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.
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. */
22 #include "as.h"
23 #include "dw2gencfi.h"
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
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
44 #ifndef EH_FRAME_ALIGNMENT
45 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
46 #endif
48 #ifndef tc_cfi_frame_initial_instructions
49 # define tc_cfi_frame_initial_instructions() ((void)0)
50 #endif
53 struct cfi_insn_data
55 struct cfi_insn_data *next;
56 int insn;
57 union {
58 struct {
59 unsigned reg;
60 offsetT offset;
61 } ri;
63 struct {
64 unsigned reg1;
65 unsigned reg2;
66 } rr;
68 unsigned r;
69 offsetT i;
71 struct {
72 symbolS *lab1;
73 symbolS *lab2;
74 } ll;
76 struct cfi_escape_data {
77 struct cfi_escape_data *next;
78 expressionS exp;
79 } *esc;
80 } u;
83 struct fde_entry
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 unsigned int signal_frame;
94 struct cie_entry
96 struct cie_entry *next;
97 symbolS *start_address;
98 unsigned int return_column;
99 unsigned int signal_frame;
100 struct cfi_insn_data *first, *last;
104 /* Current open FDE entry. */
105 static struct fde_entry *cur_fde_data;
106 static symbolS *last_address;
107 static offsetT cur_cfa_offset;
109 /* List of FDE entries. */
110 static struct fde_entry *all_fde_data;
111 static struct fde_entry **last_fde_data = &all_fde_data;
113 /* List of CIEs so that they could be reused. */
114 static struct cie_entry *cie_root;
116 /* Stack of old CFI data, for save/restore. */
117 struct cfa_save_data
119 struct cfa_save_data *next;
120 offsetT cfa_offset;
123 static struct cfa_save_data *cfa_save_stack;
125 /* Construct a new FDE structure and add it to the end of the fde list. */
127 static struct fde_entry *
128 alloc_fde_entry (void)
130 struct fde_entry *fde = xcalloc (1, sizeof (struct fde_entry));
132 cur_fde_data = fde;
133 *last_fde_data = fde;
134 last_fde_data = &fde->next;
136 fde->last = &fde->data;
137 fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
139 return fde;
142 /* The following functions are available for a backend to construct its
143 own unwind information, usually from legacy unwind directives. */
145 /* Construct a new INSN structure and add it to the end of the insn list
146 for the currently active FDE. */
148 static struct cfi_insn_data *
149 alloc_cfi_insn_data (void)
151 struct cfi_insn_data *insn = xcalloc (1, sizeof (struct cfi_insn_data));
153 *cur_fde_data->last = insn;
154 cur_fde_data->last = &insn->next;
156 return insn;
159 /* Construct a new FDE structure that begins at LABEL. */
161 void
162 cfi_new_fde (symbolS *label)
164 struct fde_entry *fde = alloc_fde_entry ();
165 fde->start_address = label;
166 last_address = label;
169 /* End the currently open FDE. */
171 void
172 cfi_end_fde (symbolS *label)
174 cur_fde_data->end_address = label;
175 cur_fde_data = NULL;
178 /* Set the return column for the current FDE. */
180 void
181 cfi_set_return_column (unsigned regno)
183 cur_fde_data->return_column = regno;
186 /* Universal functions to store new instructions. */
188 static void
189 cfi_add_CFA_insn(int insn)
191 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
193 insn_ptr->insn = insn;
196 static void
197 cfi_add_CFA_insn_reg (int insn, unsigned regno)
199 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
201 insn_ptr->insn = insn;
202 insn_ptr->u.r = regno;
205 static void
206 cfi_add_CFA_insn_offset (int insn, offsetT offset)
208 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
210 insn_ptr->insn = insn;
211 insn_ptr->u.i = offset;
214 static void
215 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
217 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
219 insn_ptr->insn = insn;
220 insn_ptr->u.rr.reg1 = reg1;
221 insn_ptr->u.rr.reg2 = reg2;
224 static void
225 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
227 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
229 insn_ptr->insn = insn;
230 insn_ptr->u.ri.reg = regno;
231 insn_ptr->u.ri.offset = offset;
234 /* Add a CFI insn to advance the PC from the last address to LABEL. */
236 void
237 cfi_add_advance_loc (symbolS *label)
239 struct cfi_insn_data *insn = alloc_cfi_insn_data ();
241 insn->insn = DW_CFA_advance_loc;
242 insn->u.ll.lab1 = last_address;
243 insn->u.ll.lab2 = label;
245 last_address = label;
248 /* Add a DW_CFA_offset record to the CFI data. */
250 void
251 cfi_add_CFA_offset (unsigned regno, offsetT offset)
253 unsigned int abs_data_align;
255 cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
257 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
258 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
259 if (offset % abs_data_align)
260 as_bad (_("register save offset not a multiple of %u"), abs_data_align);
263 /* Add a DW_CFA_def_cfa record to the CFI data. */
265 void
266 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
268 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
269 cur_cfa_offset = offset;
272 /* Add a DW_CFA_register record to the CFI data. */
274 void
275 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
277 cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
280 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
282 void
283 cfi_add_CFA_def_cfa_register (unsigned regno)
285 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
288 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
290 void
291 cfi_add_CFA_def_cfa_offset (offsetT offset)
293 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
294 cur_cfa_offset = offset;
297 void
298 cfi_add_CFA_restore (unsigned regno)
300 cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
303 void
304 cfi_add_CFA_undefined (unsigned regno)
306 cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
309 void
310 cfi_add_CFA_same_value (unsigned regno)
312 cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
315 void
316 cfi_add_CFA_remember_state (void)
318 struct cfa_save_data *p;
320 cfi_add_CFA_insn (DW_CFA_remember_state);
322 p = xmalloc (sizeof (*p));
323 p->cfa_offset = cur_cfa_offset;
324 p->next = cfa_save_stack;
325 cfa_save_stack = p;
328 void
329 cfi_add_CFA_restore_state (void)
331 struct cfa_save_data *p;
333 cfi_add_CFA_insn (DW_CFA_restore_state);
335 p = cfa_save_stack;
336 if (p)
338 cur_cfa_offset = p->cfa_offset;
339 cfa_save_stack = p->next;
340 free (p);
342 else
343 as_bad (_("CFI state restore without previous remember"));
347 /* Parse CFI assembler directives. */
349 static void dot_cfi (int);
350 static void dot_cfi_escape (int);
351 static void dot_cfi_startproc (int);
352 static void dot_cfi_endproc (int);
354 /* Fake CFI type; outside the byte range of any real CFI insn. */
355 #define CFI_adjust_cfa_offset 0x100
356 #define CFI_return_column 0x101
357 #define CFI_rel_offset 0x102
358 #define CFI_escape 0x103
359 #define CFI_signal_frame 0x104
361 const pseudo_typeS cfi_pseudo_table[] =
363 { "cfi_startproc", dot_cfi_startproc, 0 },
364 { "cfi_endproc", dot_cfi_endproc, 0 },
365 { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
366 { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
367 { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
368 { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
369 { "cfi_offset", dot_cfi, DW_CFA_offset },
370 { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
371 { "cfi_register", dot_cfi, DW_CFA_register },
372 { "cfi_return_column", dot_cfi, CFI_return_column },
373 { "cfi_restore", dot_cfi, DW_CFA_restore },
374 { "cfi_undefined", dot_cfi, DW_CFA_undefined },
375 { "cfi_same_value", dot_cfi, DW_CFA_same_value },
376 { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
377 { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
378 { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
379 { "cfi_escape", dot_cfi_escape, 0 },
380 { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
381 { NULL, NULL, 0 }
384 static void
385 cfi_parse_separator (void)
387 SKIP_WHITESPACE ();
388 if (*input_line_pointer == ',')
389 input_line_pointer++;
390 else
391 as_bad (_("missing separator"));
394 static unsigned
395 cfi_parse_reg (void)
397 int regno;
398 expressionS exp;
400 #ifdef tc_regname_to_dw2regnum
401 SKIP_WHITESPACE ();
402 if (is_name_beginner (*input_line_pointer)
403 || (*input_line_pointer == '%'
404 && is_name_beginner (*++input_line_pointer)))
406 char *name, c;
408 name = input_line_pointer;
409 c = get_symbol_end ();
411 if ((regno = tc_regname_to_dw2regnum (name)) < 0)
413 as_bad (_("bad register expression"));
414 regno = 0;
417 *input_line_pointer = c;
418 return regno;
420 #endif
422 expression_and_evaluate (&exp);
423 switch (exp.X_op)
425 case O_register:
426 case O_constant:
427 regno = exp.X_add_number;
428 break;
430 default:
431 as_bad (_("bad register expression"));
432 regno = 0;
433 break;
436 return regno;
439 static offsetT
440 cfi_parse_const (void)
442 return get_absolute_expression ();
445 static void
446 dot_cfi (int arg)
448 offsetT offset;
449 unsigned reg1, reg2;
451 if (!cur_fde_data)
453 as_bad (_("CFI instruction used without previous .cfi_startproc"));
454 ignore_rest_of_line ();
455 return;
458 /* If the last address was not at the current PC, advance to current. */
459 if (symbol_get_frag (last_address) != frag_now
460 || S_GET_VALUE (last_address) != frag_now_fix ())
461 cfi_add_advance_loc (symbol_temp_new_now ());
463 switch (arg)
465 case DW_CFA_offset:
466 reg1 = cfi_parse_reg ();
467 cfi_parse_separator ();
468 offset = cfi_parse_const ();
469 cfi_add_CFA_offset (reg1, offset);
470 break;
472 case CFI_rel_offset:
473 reg1 = cfi_parse_reg ();
474 cfi_parse_separator ();
475 offset = cfi_parse_const ();
476 cfi_add_CFA_offset (reg1, offset - cur_cfa_offset);
477 break;
479 case DW_CFA_def_cfa:
480 reg1 = cfi_parse_reg ();
481 cfi_parse_separator ();
482 offset = cfi_parse_const ();
483 cfi_add_CFA_def_cfa (reg1, offset);
484 break;
486 case DW_CFA_register:
487 reg1 = cfi_parse_reg ();
488 cfi_parse_separator ();
489 reg2 = cfi_parse_reg ();
490 cfi_add_CFA_register (reg1, reg2);
491 break;
493 case DW_CFA_def_cfa_register:
494 reg1 = cfi_parse_reg ();
495 cfi_add_CFA_def_cfa_register (reg1);
496 break;
498 case DW_CFA_def_cfa_offset:
499 offset = cfi_parse_const ();
500 cfi_add_CFA_def_cfa_offset (offset);
501 break;
503 case CFI_adjust_cfa_offset:
504 offset = cfi_parse_const ();
505 cfi_add_CFA_def_cfa_offset (cur_cfa_offset + offset);
506 break;
508 case DW_CFA_restore:
509 for (;;)
511 reg1 = cfi_parse_reg ();
512 cfi_add_CFA_restore (reg1);
513 SKIP_WHITESPACE ();
514 if (*input_line_pointer != ',')
515 break;
516 ++input_line_pointer;
518 break;
520 case DW_CFA_undefined:
521 for (;;)
523 reg1 = cfi_parse_reg ();
524 cfi_add_CFA_undefined (reg1);
525 SKIP_WHITESPACE ();
526 if (*input_line_pointer != ',')
527 break;
528 ++input_line_pointer;
530 break;
532 case DW_CFA_same_value:
533 reg1 = cfi_parse_reg ();
534 cfi_add_CFA_same_value (reg1);
535 break;
537 case CFI_return_column:
538 reg1 = cfi_parse_reg ();
539 cfi_set_return_column (reg1);
540 break;
542 case DW_CFA_remember_state:
543 cfi_add_CFA_remember_state ();
544 break;
546 case DW_CFA_restore_state:
547 cfi_add_CFA_restore_state ();
548 break;
550 case DW_CFA_GNU_window_save:
551 cfi_add_CFA_insn (DW_CFA_GNU_window_save);
552 break;
554 case CFI_signal_frame:
555 cur_fde_data->signal_frame = 1;
556 break;
558 default:
559 abort ();
562 demand_empty_rest_of_line ();
565 static void
566 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
568 struct cfi_escape_data *head, **tail, *e;
569 struct cfi_insn_data *insn;
571 if (!cur_fde_data)
573 as_bad (_("CFI instruction used without previous .cfi_startproc"));
574 ignore_rest_of_line ();
575 return;
578 /* If the last address was not at the current PC, advance to current. */
579 if (symbol_get_frag (last_address) != frag_now
580 || S_GET_VALUE (last_address) != frag_now_fix ())
581 cfi_add_advance_loc (symbol_temp_new_now ());
583 tail = &head;
586 e = xmalloc (sizeof (*e));
587 do_parse_cons_expression (&e->exp, 1);
588 *tail = e;
589 tail = &e->next;
591 while (*input_line_pointer++ == ',');
592 *tail = NULL;
594 insn = alloc_cfi_insn_data ();
595 insn->insn = CFI_escape;
596 insn->u.esc = head;
598 --input_line_pointer;
599 demand_empty_rest_of_line ();
602 static void
603 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
605 int simple = 0;
607 if (cur_fde_data)
609 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
610 ignore_rest_of_line ();
611 return;
614 cfi_new_fde (symbol_temp_new_now ());
616 SKIP_WHITESPACE ();
617 if (is_name_beginner (*input_line_pointer))
619 char *name, c;
621 name = input_line_pointer;
622 c = get_symbol_end ();
624 if (strcmp (name, "simple") == 0)
626 simple = 1;
627 *input_line_pointer = c;
629 else
630 input_line_pointer = name;
632 demand_empty_rest_of_line ();
634 cur_cfa_offset = 0;
635 if (!simple)
636 tc_cfi_frame_initial_instructions ();
639 static void
640 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
642 if (! cur_fde_data)
644 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
645 ignore_rest_of_line ();
646 return;
649 cfi_end_fde (symbol_temp_new_now ());
651 demand_empty_rest_of_line ();
655 /* Emit a single byte into the current segment. */
657 static inline void
658 out_one (int byte)
660 FRAG_APPEND_1_CHAR (byte);
663 /* Emit a two-byte word into the current segment. */
665 static inline void
666 out_two (int data)
668 md_number_to_chars (frag_more (2), data, 2);
671 /* Emit a four byte word into the current segment. */
673 static inline void
674 out_four (int data)
676 md_number_to_chars (frag_more (4), data, 4);
679 /* Emit an unsigned "little-endian base 128" number. */
681 static void
682 out_uleb128 (addressT value)
684 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
687 /* Emit an unsigned "little-endian base 128" number. */
689 static void
690 out_sleb128 (offsetT value)
692 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
695 static void
696 output_cfi_insn (struct cfi_insn_data *insn)
698 offsetT offset;
699 unsigned int regno;
701 switch (insn->insn)
703 case DW_CFA_advance_loc:
705 symbolS *from = insn->u.ll.lab1;
706 symbolS *to = insn->u.ll.lab2;
708 if (symbol_get_frag (to) == symbol_get_frag (from))
710 addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
711 addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
713 if (scaled <= 0x3F)
714 out_one (DW_CFA_advance_loc + scaled);
715 else if (delta <= 0xFF)
717 out_one (DW_CFA_advance_loc1);
718 out_one (delta);
720 else if (delta <= 0xFFFF)
722 out_one (DW_CFA_advance_loc2);
723 out_two (delta);
725 else
727 out_one (DW_CFA_advance_loc4);
728 out_four (delta);
731 else
733 expressionS exp;
735 exp.X_op = O_subtract;
736 exp.X_add_symbol = to;
737 exp.X_op_symbol = from;
738 exp.X_add_number = 0;
740 /* The code in ehopt.c expects that one byte of the encoding
741 is already allocated to the frag. This comes from the way
742 that it scans the .eh_frame section looking first for the
743 .byte DW_CFA_advance_loc4. */
744 frag_more (1);
746 frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
747 make_expr_symbol (&exp), frag_now_fix () - 1,
748 (char *) frag_now);
751 break;
753 case DW_CFA_def_cfa:
754 offset = insn->u.ri.offset;
755 if (offset < 0)
757 out_one (DW_CFA_def_cfa_sf);
758 out_uleb128 (insn->u.ri.reg);
759 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
761 else
763 out_one (DW_CFA_def_cfa);
764 out_uleb128 (insn->u.ri.reg);
765 out_uleb128 (offset);
767 break;
769 case DW_CFA_def_cfa_register:
770 case DW_CFA_undefined:
771 case DW_CFA_same_value:
772 out_one (insn->insn);
773 out_uleb128 (insn->u.r);
774 break;
776 case DW_CFA_def_cfa_offset:
777 offset = insn->u.i;
778 if (offset < 0)
780 out_one (DW_CFA_def_cfa_offset_sf);
781 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
783 else
785 out_one (DW_CFA_def_cfa_offset);
786 out_uleb128 (offset);
788 break;
790 case DW_CFA_restore:
791 regno = insn->u.r;
792 if (regno <= 0x3F)
794 out_one (DW_CFA_restore + regno);
796 else
798 out_one (DW_CFA_restore_extended);
799 out_uleb128 (regno);
801 break;
803 case DW_CFA_offset:
804 regno = insn->u.ri.reg;
805 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
806 if (offset < 0)
808 out_one (DW_CFA_offset_extended_sf);
809 out_uleb128 (regno);
810 out_sleb128 (offset);
812 else if (regno <= 0x3F)
814 out_one (DW_CFA_offset + regno);
815 out_uleb128 (offset);
817 else
819 out_one (DW_CFA_offset_extended);
820 out_uleb128 (regno);
821 out_uleb128 (offset);
823 break;
825 case DW_CFA_register:
826 out_one (DW_CFA_register);
827 out_uleb128 (insn->u.rr.reg1);
828 out_uleb128 (insn->u.rr.reg2);
829 break;
831 case DW_CFA_remember_state:
832 case DW_CFA_restore_state:
833 out_one (insn->insn);
834 break;
836 case DW_CFA_GNU_window_save:
837 out_one (DW_CFA_GNU_window_save);
838 break;
840 case CFI_escape:
842 struct cfi_escape_data *e;
843 for (e = insn->u.esc; e ; e = e->next)
844 emit_expr (&e->exp, 1);
845 break;
848 default:
849 abort ();
853 static void
854 output_cie (struct cie_entry *cie)
856 symbolS *after_size_address, *end_address;
857 expressionS exp;
858 struct cfi_insn_data *i;
860 cie->start_address = symbol_temp_new_now ();
861 after_size_address = symbol_temp_make ();
862 end_address = symbol_temp_make ();
864 exp.X_op = O_subtract;
865 exp.X_add_symbol = end_address;
866 exp.X_op_symbol = after_size_address;
867 exp.X_add_number = 0;
869 emit_expr (&exp, 4); /* Length. */
870 symbol_set_value_now (after_size_address);
871 out_four (0); /* CIE id. */
872 out_one (DW_CIE_VERSION); /* Version. */
873 out_one ('z'); /* Augmentation. */
874 out_one ('R');
875 if (cie->signal_frame)
876 out_one ('S');
877 out_one (0);
878 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */
879 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */
880 if (DW_CIE_VERSION == 1) /* Return column. */
881 out_one (cie->return_column);
882 else
883 out_uleb128 (cie->return_column);
884 out_uleb128 (1); /* Augmentation size. */
885 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
886 out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
887 #else
888 out_one (DW_EH_PE_sdata4);
889 #endif
891 if (cie->first)
892 for (i = cie->first; i != cie->last; i = i->next)
893 output_cfi_insn (i);
895 frag_align (2, DW_CFA_nop, 0);
896 symbol_set_value_now (end_address);
899 static void
900 output_fde (struct fde_entry *fde, struct cie_entry *cie,
901 struct cfi_insn_data *first, int align)
903 symbolS *after_size_address, *end_address;
904 expressionS exp;
906 after_size_address = symbol_temp_make ();
907 end_address = symbol_temp_make ();
909 exp.X_op = O_subtract;
910 exp.X_add_symbol = end_address;
911 exp.X_op_symbol = after_size_address;
912 exp.X_add_number = 0;
913 emit_expr (&exp, 4); /* Length. */
914 symbol_set_value_now (after_size_address);
916 exp.X_add_symbol = after_size_address;
917 exp.X_op_symbol = cie->start_address;
918 emit_expr (&exp, 4); /* CIE offset. */
920 #ifdef DIFF_EXPR_OK
921 exp.X_add_symbol = fde->start_address;
922 exp.X_op_symbol = symbol_temp_new_now ();
923 emit_expr (&exp, 4); /* Code offset. */
924 #else
925 exp.X_op = O_symbol;
926 exp.X_add_symbol = fde->start_address;
927 exp.X_op_symbol = NULL;
928 #ifdef tc_cfi_emit_pcrel_expr
929 tc_cfi_emit_pcrel_expr (&exp, 4); /* Code offset. */
930 #else
931 emit_expr (&exp, 4); /* Code offset. */
932 #endif
933 exp.X_op = O_subtract;
934 #endif
936 exp.X_add_symbol = fde->end_address;
937 exp.X_op_symbol = fde->start_address; /* Code length. */
938 emit_expr (&exp, 4);
940 out_uleb128 (0); /* Augmentation size. */
942 for (; first; first = first->next)
943 output_cfi_insn (first);
945 frag_align (align, DW_CFA_nop, 0);
946 symbol_set_value_now (end_address);
949 static struct cie_entry *
950 select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
952 struct cfi_insn_data *i, *j;
953 struct cie_entry *cie;
955 for (cie = cie_root; cie; cie = cie->next)
957 if (cie->return_column != fde->return_column
958 || cie->signal_frame != fde->signal_frame)
959 continue;
960 for (i = cie->first, j = fde->data;
961 i != cie->last && j != NULL;
962 i = i->next, j = j->next)
964 if (i->insn != j->insn)
965 goto fail;
966 switch (i->insn)
968 case DW_CFA_advance_loc:
969 case DW_CFA_remember_state:
970 /* We reached the first advance/remember in the FDE,
971 but did not reach the end of the CIE list. */
972 goto fail;
974 case DW_CFA_offset:
975 case DW_CFA_def_cfa:
976 if (i->u.ri.reg != j->u.ri.reg)
977 goto fail;
978 if (i->u.ri.offset != j->u.ri.offset)
979 goto fail;
980 break;
982 case DW_CFA_register:
983 if (i->u.rr.reg1 != j->u.rr.reg1)
984 goto fail;
985 if (i->u.rr.reg2 != j->u.rr.reg2)
986 goto fail;
987 break;
989 case DW_CFA_def_cfa_register:
990 case DW_CFA_restore:
991 case DW_CFA_undefined:
992 case DW_CFA_same_value:
993 if (i->u.r != j->u.r)
994 goto fail;
995 break;
997 case DW_CFA_def_cfa_offset:
998 if (i->u.i != j->u.i)
999 goto fail;
1000 break;
1002 case CFI_escape:
1003 /* Don't bother matching these for now. */
1004 goto fail;
1006 default:
1007 abort ();
1011 /* Success if we reached the end of the CIE list, and we've either
1012 run out of FDE entries or we've encountered an advance,
1013 remember, or escape. */
1014 if (i == cie->last
1015 && (!j
1016 || j->insn == DW_CFA_advance_loc
1017 || j->insn == DW_CFA_remember_state
1018 || j->insn == CFI_escape))
1020 *pfirst = j;
1021 return cie;
1024 fail:;
1027 cie = xmalloc (sizeof (struct cie_entry));
1028 cie->next = cie_root;
1029 cie_root = cie;
1030 cie->return_column = fde->return_column;
1031 cie->signal_frame = fde->signal_frame;
1032 cie->first = fde->data;
1034 for (i = cie->first; i ; i = i->next)
1035 if (i->insn == DW_CFA_advance_loc
1036 || i->insn == DW_CFA_remember_state
1037 || i->insn == CFI_escape)
1038 break;
1040 cie->last = i;
1041 *pfirst = i;
1043 output_cie (cie);
1045 return cie;
1048 void
1049 cfi_finish (void)
1051 segT cfi_seg;
1052 struct fde_entry *fde;
1053 int save_flag_traditional_format;
1055 if (cur_fde_data)
1057 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1058 cur_fde_data->end_address = cur_fde_data->start_address;
1061 if (all_fde_data == 0)
1062 return;
1064 /* Open .eh_frame section. */
1065 cfi_seg = subseg_new (".eh_frame", 0);
1066 bfd_set_section_flags (stdoutput, cfi_seg,
1067 SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1068 subseg_set (cfi_seg, 0);
1069 record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1071 /* Make sure check_eh_frame doesn't do anything with our output. */
1072 save_flag_traditional_format = flag_traditional_format;
1073 flag_traditional_format = 1;
1075 for (fde = all_fde_data; fde ; fde = fde->next)
1077 struct cfi_insn_data *first;
1078 struct cie_entry *cie;
1080 cie = select_cie_for_fde (fde, &first);
1081 output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1084 flag_traditional_format = save_flag_traditional_format;