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>
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)
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
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
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
39 # ifndef DWARF2_CIE_DATA_ALIGNMENT
40 # define DWARF2_CIE_DATA_ALIGNMENT 1
44 #ifndef EH_FRAME_ALIGNMENT
45 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
48 #ifndef tc_cfi_frame_initial_instructions
49 # define tc_cfi_frame_initial_instructions() ((void)0)
55 struct cfi_insn_data
*next
;
76 struct cfi_escape_data
{
77 struct cfi_escape_data
*next
;
85 struct fde_entry
*next
;
86 symbolS
*start_address
;
88 struct cfi_insn_data
*data
;
89 struct cfi_insn_data
**last
;
90 unsigned int return_column
;
95 struct cie_entry
*next
;
96 symbolS
*start_address
;
97 unsigned int return_column
;
98 struct cfi_insn_data
*first
, *last
;
102 /* Current open FDE entry. */
103 static struct fde_entry
*cur_fde_data
;
104 static symbolS
*last_address
;
105 static offsetT cur_cfa_offset
;
107 /* List of FDE entries. */
108 static struct fde_entry
*all_fde_data
;
109 static struct fde_entry
**last_fde_data
= &all_fde_data
;
111 /* List of CIEs so that they could be reused. */
112 static struct cie_entry
*cie_root
;
114 /* Stack of old CFI data, for save/restore. */
117 struct cfa_save_data
*next
;
121 static struct cfa_save_data
*cfa_save_stack
;
123 /* Construct a new FDE structure and add it to the end of the fde list. */
125 static struct fde_entry
*
126 alloc_fde_entry (void)
128 struct fde_entry
*fde
= xcalloc (1, sizeof (struct fde_entry
));
131 *last_fde_data
= fde
;
132 last_fde_data
= &fde
->next
;
134 fde
->last
= &fde
->data
;
135 fde
->return_column
= DWARF2_DEFAULT_RETURN_COLUMN
;
140 /* The following functions are available for a backend to construct its
141 own unwind information, usually from legacy unwind directives. */
143 /* Construct a new INSN structure and add it to the end of the insn list
144 for the currently active FDE. */
146 static struct cfi_insn_data
*
147 alloc_cfi_insn_data (void)
149 struct cfi_insn_data
*insn
= xcalloc (1, sizeof (struct cfi_insn_data
));
151 *cur_fde_data
->last
= insn
;
152 cur_fde_data
->last
= &insn
->next
;
157 /* Construct a new FDE structure that begins at LABEL. */
160 cfi_new_fde (symbolS
*label
)
162 struct fde_entry
*fde
= alloc_fde_entry ();
163 fde
->start_address
= label
;
164 last_address
= label
;
167 /* End the currently open FDE. */
170 cfi_end_fde (symbolS
*label
)
172 cur_fde_data
->end_address
= label
;
176 /* Set the return column for the current FDE. */
179 cfi_set_return_column (unsigned regno
)
181 cur_fde_data
->return_column
= regno
;
184 /* Universal functions to store new instructions. */
187 cfi_add_CFA_insn(int insn
)
189 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
191 insn_ptr
->insn
= insn
;
195 cfi_add_CFA_insn_reg (int insn
, unsigned regno
)
197 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
199 insn_ptr
->insn
= insn
;
200 insn_ptr
->u
.r
= regno
;
204 cfi_add_CFA_insn_offset (int insn
, offsetT offset
)
206 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
208 insn_ptr
->insn
= insn
;
209 insn_ptr
->u
.i
= offset
;
213 cfi_add_CFA_insn_reg_reg (int insn
, unsigned reg1
, unsigned reg2
)
215 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
217 insn_ptr
->insn
= insn
;
218 insn_ptr
->u
.rr
.reg1
= reg1
;
219 insn_ptr
->u
.rr
.reg2
= reg2
;
223 cfi_add_CFA_insn_reg_offset (int insn
, unsigned regno
, offsetT offset
)
225 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
227 insn_ptr
->insn
= insn
;
228 insn_ptr
->u
.ri
.reg
= regno
;
229 insn_ptr
->u
.ri
.offset
= offset
;
232 /* Add a CFI insn to advance the PC from the last address to LABEL. */
235 cfi_add_advance_loc (symbolS
*label
)
237 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
239 insn
->insn
= DW_CFA_advance_loc
;
240 insn
->u
.ll
.lab1
= last_address
;
241 insn
->u
.ll
.lab2
= label
;
243 last_address
= label
;
246 /* Add a DW_CFA_offset record to the CFI data. */
249 cfi_add_CFA_offset (unsigned regno
, offsetT offset
)
251 unsigned int abs_data_align
;
253 cfi_add_CFA_insn_reg_offset (DW_CFA_offset
, regno
, offset
);
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
);
261 /* Add a DW_CFA_def_cfa record to the CFI data. */
264 cfi_add_CFA_def_cfa (unsigned regno
, offsetT offset
)
266 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa
, regno
, offset
);
267 cur_cfa_offset
= offset
;
270 /* Add a DW_CFA_register record to the CFI data. */
273 cfi_add_CFA_register (unsigned reg1
, unsigned reg2
)
275 cfi_add_CFA_insn_reg_reg (DW_CFA_register
, reg1
, reg2
);
278 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
281 cfi_add_CFA_def_cfa_register (unsigned regno
)
283 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register
, regno
);
286 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
289 cfi_add_CFA_def_cfa_offset (offsetT offset
)
291 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset
, offset
);
292 cur_cfa_offset
= offset
;
296 cfi_add_CFA_restore (unsigned regno
)
298 cfi_add_CFA_insn_reg (DW_CFA_restore
, regno
);
302 cfi_add_CFA_undefined (unsigned regno
)
304 cfi_add_CFA_insn_reg (DW_CFA_undefined
, regno
);
308 cfi_add_CFA_same_value (unsigned regno
)
310 cfi_add_CFA_insn_reg (DW_CFA_same_value
, regno
);
314 cfi_add_CFA_remember_state (void)
316 struct cfa_save_data
*p
;
318 cfi_add_CFA_insn (DW_CFA_remember_state
);
320 p
= xmalloc (sizeof (*p
));
321 p
->cfa_offset
= cur_cfa_offset
;
322 p
->next
= cfa_save_stack
;
327 cfi_add_CFA_restore_state (void)
329 struct cfa_save_data
*p
;
331 cfi_add_CFA_insn (DW_CFA_restore_state
);
336 cur_cfa_offset
= p
->cfa_offset
;
337 cfa_save_stack
= p
->next
;
341 as_bad (_("CFI state restore without previous remember"));
345 /* Parse CFI assembler directives. */
347 static void dot_cfi (int);
348 static void dot_cfi_escape (int);
349 static void dot_cfi_startproc (int);
350 static void dot_cfi_endproc (int);
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
358 const pseudo_typeS cfi_pseudo_table
[] =
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 },
381 cfi_parse_separator (void)
384 if (*input_line_pointer
== ',')
385 input_line_pointer
++;
387 as_bad (_("missing separator"));
396 #ifdef tc_regname_to_dw2regnum
398 if (is_name_beginner (*input_line_pointer
)
399 || (*input_line_pointer
== '%'
400 && is_name_beginner (*++input_line_pointer
)))
404 name
= input_line_pointer
;
405 c
= get_symbol_end ();
407 if ((regno
= tc_regname_to_dw2regnum (name
)) < 0)
409 as_bad (_("bad register expression"));
413 *input_line_pointer
= c
;
423 regno
= exp
.X_add_number
;
427 as_bad (_("bad register expression"));
436 cfi_parse_const (void)
438 return get_absolute_expression ();
449 as_bad (_("CFI instruction used without previous .cfi_startproc"));
450 ignore_rest_of_line ();
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 ());
462 reg1
= cfi_parse_reg ();
463 cfi_parse_separator ();
464 offset
= cfi_parse_const ();
465 cfi_add_CFA_offset (reg1
, 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
);
476 reg1
= cfi_parse_reg ();
477 cfi_parse_separator ();
478 offset
= cfi_parse_const ();
479 cfi_add_CFA_def_cfa (reg1
, offset
);
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
);
489 case DW_CFA_def_cfa_register
:
490 reg1
= cfi_parse_reg ();
491 cfi_add_CFA_def_cfa_register (reg1
);
494 case DW_CFA_def_cfa_offset
:
495 offset
= cfi_parse_const ();
496 cfi_add_CFA_def_cfa_offset (offset
);
499 case CFI_adjust_cfa_offset
:
500 offset
= cfi_parse_const ();
501 cfi_add_CFA_def_cfa_offset (cur_cfa_offset
+ offset
);
505 reg1
= cfi_parse_reg ();
506 cfi_add_CFA_restore (reg1
);
509 case DW_CFA_undefined
:
510 reg1
= cfi_parse_reg ();
511 cfi_add_CFA_undefined (reg1
);
514 case DW_CFA_same_value
:
515 reg1
= cfi_parse_reg ();
516 cfi_add_CFA_same_value (reg1
);
519 case CFI_return_column
:
520 reg1
= cfi_parse_reg ();
521 cfi_set_return_column (reg1
);
524 case DW_CFA_remember_state
:
525 cfi_add_CFA_remember_state ();
528 case DW_CFA_restore_state
:
529 cfi_add_CFA_restore_state ();
532 case DW_CFA_GNU_window_save
:
533 cfi_add_CFA_insn (DW_CFA_GNU_window_save
);
540 demand_empty_rest_of_line ();
544 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED
)
546 struct cfi_escape_data
*head
, **tail
, *e
;
547 struct cfi_insn_data
*insn
;
551 as_bad (_("CFI instruction used without previous .cfi_startproc"));
552 ignore_rest_of_line ();
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 ());
564 e
= xmalloc (sizeof (*e
));
565 do_parse_cons_expression (&e
->exp
, 1);
569 while (*input_line_pointer
++ == ',');
572 insn
= alloc_cfi_insn_data ();
573 insn
->insn
= CFI_escape
;
576 --input_line_pointer
;
577 demand_empty_rest_of_line ();
581 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED
)
587 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
588 ignore_rest_of_line ();
592 cfi_new_fde (symbol_temp_new_now ());
595 if (is_name_beginner (*input_line_pointer
))
599 name
= input_line_pointer
;
600 c
= get_symbol_end ();
602 if (strcmp (name
, "simple") == 0)
605 *input_line_pointer
= c
;
608 input_line_pointer
= name
;
610 demand_empty_rest_of_line ();
614 tc_cfi_frame_initial_instructions ();
618 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED
)
622 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
623 ignore_rest_of_line ();
627 cfi_end_fde (symbol_temp_new_now ());
629 demand_empty_rest_of_line ();
633 /* Emit a single byte into the current segment. */
638 FRAG_APPEND_1_CHAR (byte
);
641 /* Emit a two-byte word into the current segment. */
646 md_number_to_chars (frag_more (2), data
, 2);
649 /* Emit a four byte word into the current segment. */
654 md_number_to_chars (frag_more (4), data
, 4);
657 /* Emit an unsigned "little-endian base 128" number. */
660 out_uleb128 (addressT value
)
662 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
665 /* Emit an unsigned "little-endian base 128" number. */
668 out_sleb128 (offsetT value
)
670 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
674 output_cfi_insn (struct cfi_insn_data
*insn
)
681 case DW_CFA_advance_loc
:
683 symbolS
*from
= insn
->u
.ll
.lab1
;
684 symbolS
*to
= insn
->u
.ll
.lab2
;
686 if (symbol_get_frag (to
) == symbol_get_frag (from
))
688 addressT delta
= S_GET_VALUE (to
) - S_GET_VALUE (from
);
689 addressT scaled
= delta
/ DWARF2_LINE_MIN_INSN_LENGTH
;
692 out_one (DW_CFA_advance_loc
+ scaled
);
693 else if (delta
<= 0xFF)
695 out_one (DW_CFA_advance_loc1
);
698 else if (delta
<= 0xFFFF)
700 out_one (DW_CFA_advance_loc2
);
705 out_one (DW_CFA_advance_loc4
);
713 exp
.X_op
= O_subtract
;
714 exp
.X_add_symbol
= to
;
715 exp
.X_op_symbol
= from
;
716 exp
.X_add_number
= 0;
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. */
724 frag_var (rs_cfa
, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH
<< 3,
725 make_expr_symbol (&exp
), frag_now_fix () - 1,
732 offset
= insn
->u
.ri
.offset
;
735 out_one (DW_CFA_def_cfa_sf
);
736 out_uleb128 (insn
->u
.ri
.reg
);
737 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
741 out_one (DW_CFA_def_cfa
);
742 out_uleb128 (insn
->u
.ri
.reg
);
743 out_uleb128 (offset
);
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
);
754 case DW_CFA_def_cfa_offset
:
758 out_one (DW_CFA_def_cfa_offset_sf
);
759 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
763 out_one (DW_CFA_def_cfa_offset
);
764 out_uleb128 (offset
);
772 out_one (DW_CFA_restore
+ regno
);
776 out_one (DW_CFA_restore_extended
);
782 regno
= insn
->u
.ri
.reg
;
783 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
786 out_one (DW_CFA_offset_extended_sf
);
788 out_sleb128 (offset
);
790 else if (regno
<= 0x3F)
792 out_one (DW_CFA_offset
+ regno
);
793 out_uleb128 (offset
);
797 out_one (DW_CFA_offset_extended
);
799 out_uleb128 (offset
);
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
);
809 case DW_CFA_remember_state
:
810 case DW_CFA_restore_state
:
811 out_one (insn
->insn
);
814 case DW_CFA_GNU_window_save
:
815 out_one (DW_CFA_GNU_window_save
);
820 struct cfi_escape_data
*e
;
821 for (e
= insn
->u
.esc
; e
; e
= e
->next
)
822 emit_expr (&e
->exp
, 1);
832 output_cie (struct cie_entry
*cie
)
834 symbolS
*after_size_address
, *end_address
;
836 struct cfi_insn_data
*i
;
838 cie
->start_address
= symbol_temp_new_now ();
839 after_size_address
= symbol_temp_make ();
840 end_address
= symbol_temp_make ();
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;
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. */
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
);
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
);
864 out_one (DW_EH_PE_sdata4
);
868 for (i
= cie
->first
; i
!= cie
->last
; i
= i
->next
)
871 frag_align (2, DW_CFA_nop
, 0);
872 symbol_set_value_now (end_address
);
876 output_fde (struct fde_entry
*fde
, struct cie_entry
*cie
,
877 struct cfi_insn_data
*first
, int align
)
879 symbolS
*after_size_address
, *end_address
;
882 after_size_address
= symbol_temp_make ();
883 end_address
= symbol_temp_make ();
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
);
892 exp
.X_add_symbol
= after_size_address
;
893 exp
.X_op_symbol
= cie
->start_address
;
894 emit_expr (&exp
, 4); /* CIE offset. */
897 exp
.X_add_symbol
= fde
->start_address
;
898 exp
.X_op_symbol
= symbol_temp_new_now ();
899 emit_expr (&exp
, 4); /* Code offset. */
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. */
907 emit_expr (&exp
, 4); /* Code offset. */
909 exp
.X_op
= O_subtract
;
912 exp
.X_add_symbol
= fde
->end_address
;
913 exp
.X_op_symbol
= fde
->start_address
; /* Code length. */
916 out_uleb128 (0); /* Augmentation size. */
918 for (; first
; first
= first
->next
)
919 output_cfi_insn (first
);
921 frag_align (align
, DW_CFA_nop
, 0);
922 symbol_set_value_now (end_address
);
925 static struct cie_entry
*
926 select_cie_for_fde (struct fde_entry
*fde
, struct cfi_insn_data
**pfirst
)
928 struct cfi_insn_data
*i
, *j
;
929 struct cie_entry
*cie
;
931 for (cie
= cie_root
; cie
; cie
= cie
->next
)
933 if (cie
->return_column
!= fde
->return_column
)
935 for (i
= cie
->first
, j
= fde
->data
;
936 i
!= cie
->last
&& j
!= NULL
;
937 i
= i
->next
, j
= j
->next
)
939 if (i
->insn
!= j
->insn
)
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. */
951 if (i
->u
.ri
.reg
!= j
->u
.ri
.reg
)
953 if (i
->u
.ri
.offset
!= j
->u
.ri
.offset
)
957 case DW_CFA_register
:
958 if (i
->u
.rr
.reg1
!= j
->u
.rr
.reg1
)
960 if (i
->u
.rr
.reg2
!= j
->u
.rr
.reg2
)
964 case DW_CFA_def_cfa_register
:
966 case DW_CFA_undefined
:
967 case DW_CFA_same_value
:
968 if (i
->u
.r
!= j
->u
.r
)
972 case DW_CFA_def_cfa_offset
:
973 if (i
->u
.i
!= j
->u
.i
)
978 /* Don't bother matching these for now. */
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. */
991 || j
->insn
== DW_CFA_advance_loc
992 || j
->insn
== DW_CFA_remember_state
993 || j
->insn
== CFI_escape
))
1002 cie
= xmalloc (sizeof (struct cie_entry
));
1003 cie
->next
= cie_root
;
1005 cie
->return_column
= fde
->return_column
;
1006 cie
->first
= fde
->data
;
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
)
1026 struct fde_entry
*fde
;
1027 int save_flag_traditional_format
;
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
;
1035 if (all_fde_data
== 0)
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
);
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;
1049 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1051 struct cfi_insn_data
*first
;
1052 struct cie_entry
*cie
;
1054 cie
= select_cie_for_fde (fde
, &first
);
1055 output_fde (fde
, cie
, first
, fde
->next
== NULL
? EH_FRAME_ALIGNMENT
: 2);
1058 flag_traditional_format
= save_flag_traditional_format
;