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)
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;
91 unsigned int signal_frame;
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. */
119 struct cfa_save_data *next;
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));
133 *last_fde_data = fde;
134 last_fde_data = &fde->next;
136 fde->last = &fde->data;
137 fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
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;
159 /* Construct a new FDE structure that begins at LABEL. */
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. */
172 cfi_end_fde (symbolS *label)
174 cur_fde_data->end_address = label;
178 /* Set the return column for the current FDE. */
181 cfi_set_return_column (unsigned regno)
183 cur_fde_data->return_column = regno;
186 /* Universal functions to store new instructions. */
189 cfi_add_CFA_insn(int insn)
191 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
193 insn_ptr->insn = insn;
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;
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;
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;
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. */
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. */
251 cfi_add_CFA_offset (unsigned regno, offsetT offset)
253 unsigned int abs_data_align;
255 assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
256 cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
258 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
259 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
260 if (offset % abs_data_align)
261 as_bad (_("register save offset not a multiple of %u"), abs_data_align);
264 /* Add a DW_CFA_def_cfa record to the CFI data. */
267 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
269 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
270 cur_cfa_offset = offset;
273 /* Add a DW_CFA_register record to the CFI data. */
276 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
278 cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
281 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
284 cfi_add_CFA_def_cfa_register (unsigned regno)
286 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
289 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
292 cfi_add_CFA_def_cfa_offset (offsetT offset)
294 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
295 cur_cfa_offset = offset;
299 cfi_add_CFA_restore (unsigned regno)
301 cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
305 cfi_add_CFA_undefined (unsigned regno)
307 cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
311 cfi_add_CFA_same_value (unsigned regno)
313 cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
317 cfi_add_CFA_remember_state (void)
319 struct cfa_save_data *p;
321 cfi_add_CFA_insn (DW_CFA_remember_state);
323 p = xmalloc (sizeof (*p));
324 p->cfa_offset = cur_cfa_offset;
325 p->next = cfa_save_stack;
330 cfi_add_CFA_restore_state (void)
332 struct cfa_save_data *p;
334 cfi_add_CFA_insn (DW_CFA_restore_state);
339 cur_cfa_offset = p->cfa_offset;
340 cfa_save_stack = p->next;
344 as_bad (_("CFI state restore without previous remember"));
348 /* Parse CFI assembler directives. */
350 static void dot_cfi (int);
351 static void dot_cfi_escape (int);
352 static void dot_cfi_startproc (int);
353 static void dot_cfi_endproc (int);
355 /* Fake CFI type; outside the byte range of any real CFI insn. */
356 #define CFI_adjust_cfa_offset 0x100
357 #define CFI_return_column 0x101
358 #define CFI_rel_offset 0x102
359 #define CFI_escape 0x103
360 #define CFI_signal_frame 0x104
362 const pseudo_typeS cfi_pseudo_table[] =
364 { "cfi_startproc", dot_cfi_startproc, 0 },
365 { "cfi_endproc", dot_cfi_endproc, 0 },
366 { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
367 { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
368 { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
369 { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
370 { "cfi_offset", dot_cfi, DW_CFA_offset },
371 { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
372 { "cfi_register", dot_cfi, DW_CFA_register },
373 { "cfi_return_column", dot_cfi, CFI_return_column },
374 { "cfi_restore", dot_cfi, DW_CFA_restore },
375 { "cfi_undefined", dot_cfi, DW_CFA_undefined },
376 { "cfi_same_value", dot_cfi, DW_CFA_same_value },
377 { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
378 { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
379 { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
380 { "cfi_escape", dot_cfi_escape, 0 },
381 { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
386 cfi_parse_separator (void)
389 if (*input_line_pointer == ',')
390 input_line_pointer++;
392 as_bad (_("missing separator"));
401 #ifdef tc_regname_to_dw2regnum
403 if (is_name_beginner (*input_line_pointer)
404 || (*input_line_pointer == '%'
405 && is_name_beginner (*++input_line_pointer)))
409 name = input_line_pointer;
410 c = get_symbol_end ();
412 if ((regno = tc_regname_to_dw2regnum (name)) < 0)
414 as_bad (_("bad register expression"));
418 *input_line_pointer = c;
423 expression_and_evaluate (&exp);
428 regno = exp.X_add_number;
432 as_bad (_("bad register expression"));
441 cfi_parse_const (void)
443 return get_absolute_expression ();
454 as_bad (_("CFI instruction used without previous .cfi_startproc"));
455 ignore_rest_of_line ();
459 /* If the last address was not at the current PC, advance to current. */
460 if (symbol_get_frag (last_address) != frag_now
461 || S_GET_VALUE (last_address) != frag_now_fix ())
462 cfi_add_advance_loc (symbol_temp_new_now ());
467 reg1 = cfi_parse_reg ();
468 cfi_parse_separator ();
469 offset = cfi_parse_const ();
470 cfi_add_CFA_offset (reg1, offset);
474 reg1 = cfi_parse_reg ();
475 cfi_parse_separator ();
476 offset = cfi_parse_const ();
477 cfi_add_CFA_offset (reg1, offset - cur_cfa_offset);
481 reg1 = cfi_parse_reg ();
482 cfi_parse_separator ();
483 offset = cfi_parse_const ();
484 cfi_add_CFA_def_cfa (reg1, offset);
487 case DW_CFA_register:
488 reg1 = cfi_parse_reg ();
489 cfi_parse_separator ();
490 reg2 = cfi_parse_reg ();
491 cfi_add_CFA_register (reg1, reg2);
494 case DW_CFA_def_cfa_register:
495 reg1 = cfi_parse_reg ();
496 cfi_add_CFA_def_cfa_register (reg1);
499 case DW_CFA_def_cfa_offset:
500 offset = cfi_parse_const ();
501 cfi_add_CFA_def_cfa_offset (offset);
504 case CFI_adjust_cfa_offset:
505 offset = cfi_parse_const ();
506 cfi_add_CFA_def_cfa_offset (cur_cfa_offset + offset);
512 reg1 = cfi_parse_reg ();
513 cfi_add_CFA_restore (reg1);
515 if (*input_line_pointer != ',')
517 ++input_line_pointer;
521 case DW_CFA_undefined:
524 reg1 = cfi_parse_reg ();
525 cfi_add_CFA_undefined (reg1);
527 if (*input_line_pointer != ',')
529 ++input_line_pointer;
533 case DW_CFA_same_value:
534 reg1 = cfi_parse_reg ();
535 cfi_add_CFA_same_value (reg1);
538 case CFI_return_column:
539 reg1 = cfi_parse_reg ();
540 cfi_set_return_column (reg1);
543 case DW_CFA_remember_state:
544 cfi_add_CFA_remember_state ();
547 case DW_CFA_restore_state:
548 cfi_add_CFA_restore_state ();
551 case DW_CFA_GNU_window_save:
552 cfi_add_CFA_insn (DW_CFA_GNU_window_save);
555 case CFI_signal_frame:
556 cur_fde_data->signal_frame = 1;
563 demand_empty_rest_of_line ();
567 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
569 struct cfi_escape_data *head, **tail, *e;
570 struct cfi_insn_data *insn;
574 as_bad (_("CFI instruction used without previous .cfi_startproc"));
575 ignore_rest_of_line ();
579 /* If the last address was not at the current PC, advance to current. */
580 if (symbol_get_frag (last_address) != frag_now
581 || S_GET_VALUE (last_address) != frag_now_fix ())
582 cfi_add_advance_loc (symbol_temp_new_now ());
587 e = xmalloc (sizeof (*e));
588 do_parse_cons_expression (&e->exp, 1);
592 while (*input_line_pointer++ == ',');
595 insn = alloc_cfi_insn_data ();
596 insn->insn = CFI_escape;
599 --input_line_pointer;
600 demand_empty_rest_of_line ();
604 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
610 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
611 ignore_rest_of_line ();
615 cfi_new_fde (symbol_temp_new_now ());
618 if (is_name_beginner (*input_line_pointer))
622 name = input_line_pointer;
623 c = get_symbol_end ();
625 if (strcmp (name, "simple") == 0)
628 *input_line_pointer = c;
631 input_line_pointer = name;
633 demand_empty_rest_of_line ();
637 tc_cfi_frame_initial_instructions ();
641 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
645 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
646 ignore_rest_of_line ();
650 cfi_end_fde (symbol_temp_new_now ());
652 demand_empty_rest_of_line ();
656 /* Emit a single byte into the current segment. */
661 FRAG_APPEND_1_CHAR (byte);
664 /* Emit a two-byte word into the current segment. */
669 md_number_to_chars (frag_more (2), data, 2);
672 /* Emit a four byte word into the current segment. */
677 md_number_to_chars (frag_more (4), data, 4);
680 /* Emit an unsigned "little-endian base 128" number. */
683 out_uleb128 (addressT value)
685 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
688 /* Emit an unsigned "little-endian base 128" number. */
691 out_sleb128 (offsetT value)
693 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
697 output_cfi_insn (struct cfi_insn_data *insn)
704 case DW_CFA_advance_loc:
706 symbolS *from = insn->u.ll.lab1;
707 symbolS *to = insn->u.ll.lab2;
709 if (symbol_get_frag (to) == symbol_get_frag (from))
711 addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
712 addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
715 out_one (DW_CFA_advance_loc + scaled);
716 else if (delta <= 0xFF)
718 out_one (DW_CFA_advance_loc1);
721 else if (delta <= 0xFFFF)
723 out_one (DW_CFA_advance_loc2);
728 out_one (DW_CFA_advance_loc4);
736 exp.X_op = O_subtract;
737 exp.X_add_symbol = to;
738 exp.X_op_symbol = from;
739 exp.X_add_number = 0;
741 /* The code in ehopt.c expects that one byte of the encoding
742 is already allocated to the frag. This comes from the way
743 that it scans the .eh_frame section looking first for the
744 .byte DW_CFA_advance_loc4. */
747 frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
748 make_expr_symbol (&exp), frag_now_fix () - 1,
755 offset = insn->u.ri.offset;
758 out_one (DW_CFA_def_cfa_sf);
759 out_uleb128 (insn->u.ri.reg);
760 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
764 out_one (DW_CFA_def_cfa);
765 out_uleb128 (insn->u.ri.reg);
766 out_uleb128 (offset);
770 case DW_CFA_def_cfa_register:
771 case DW_CFA_undefined:
772 case DW_CFA_same_value:
773 out_one (insn->insn);
774 out_uleb128 (insn->u.r);
777 case DW_CFA_def_cfa_offset:
781 out_one (DW_CFA_def_cfa_offset_sf);
782 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
786 out_one (DW_CFA_def_cfa_offset);
787 out_uleb128 (offset);
795 out_one (DW_CFA_restore + regno);
799 out_one (DW_CFA_restore_extended);
805 regno = insn->u.ri.reg;
806 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
809 out_one (DW_CFA_offset_extended_sf);
811 out_sleb128 (offset);
813 else if (regno <= 0x3F)
815 out_one (DW_CFA_offset + regno);
816 out_uleb128 (offset);
820 out_one (DW_CFA_offset_extended);
822 out_uleb128 (offset);
826 case DW_CFA_register:
827 out_one (DW_CFA_register);
828 out_uleb128 (insn->u.rr.reg1);
829 out_uleb128 (insn->u.rr.reg2);
832 case DW_CFA_remember_state:
833 case DW_CFA_restore_state:
834 out_one (insn->insn);
837 case DW_CFA_GNU_window_save:
838 out_one (DW_CFA_GNU_window_save);
843 struct cfi_escape_data *e;
844 for (e = insn->u.esc; e ; e = e->next)
845 emit_expr (&e->exp, 1);
855 output_cie (struct cie_entry *cie)
857 symbolS *after_size_address, *end_address;
859 struct cfi_insn_data *i;
861 cie->start_address = symbol_temp_new_now ();
862 after_size_address = symbol_temp_make ();
863 end_address = symbol_temp_make ();
865 exp.X_op = O_subtract;
866 exp.X_add_symbol = end_address;
867 exp.X_op_symbol = after_size_address;
868 exp.X_add_number = 0;
870 emit_expr (&exp, 4); /* Length. */
871 symbol_set_value_now (after_size_address);
872 out_four (0); /* CIE id. */
873 out_one (DW_CIE_VERSION); /* Version. */
874 out_one ('z'); /* Augmentation. */
876 if (cie->signal_frame)
879 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */
880 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */
881 if (DW_CIE_VERSION == 1) /* Return column. */
882 out_one (cie->return_column);
884 out_uleb128 (cie->return_column);
885 out_uleb128 (1); /* Augmentation size. */
886 #if defined DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
887 out_one (DW_EH_PE_pcrel | DW_EH_PE_sdata4);
889 out_one (DW_EH_PE_sdata4);
893 for (i = cie->first; i != cie->last; i = i->next)
896 frag_align (2, DW_CFA_nop, 0);
897 symbol_set_value_now (end_address);
901 output_fde (struct fde_entry *fde, struct cie_entry *cie,
902 struct cfi_insn_data *first, int align)
904 symbolS *after_size_address, *end_address;
907 after_size_address = symbol_temp_make ();
908 end_address = symbol_temp_make ();
910 exp.X_op = O_subtract;
911 exp.X_add_symbol = end_address;
912 exp.X_op_symbol = after_size_address;
913 exp.X_add_number = 0;
914 emit_expr (&exp, 4); /* Length. */
915 symbol_set_value_now (after_size_address);
917 exp.X_add_symbol = after_size_address;
918 exp.X_op_symbol = cie->start_address;
919 emit_expr (&exp, 4); /* CIE offset. */
922 exp.X_add_symbol = fde->start_address;
923 exp.X_op_symbol = symbol_temp_new_now ();
924 emit_expr (&exp, 4); /* Code offset. */
927 exp.X_add_symbol = fde->start_address;
928 exp.X_op_symbol = NULL;
929 #ifdef tc_cfi_emit_pcrel_expr
930 tc_cfi_emit_pcrel_expr (&exp, 4); /* Code offset. */
932 emit_expr (&exp, 4); /* Code offset. */
934 exp.X_op = O_subtract;
937 exp.X_add_symbol = fde->end_address;
938 exp.X_op_symbol = fde->start_address; /* Code length. */
941 out_uleb128 (0); /* Augmentation size. */
943 for (; first; first = first->next)
944 output_cfi_insn (first);
946 frag_align (align, DW_CFA_nop, 0);
947 symbol_set_value_now (end_address);
950 static struct cie_entry *
951 select_cie_for_fde (struct fde_entry *fde, struct cfi_insn_data **pfirst)
953 struct cfi_insn_data *i, *j;
954 struct cie_entry *cie;
956 for (cie = cie_root; cie; cie = cie->next)
958 if (cie->return_column != fde->return_column
959 || cie->signal_frame != fde->signal_frame)
961 for (i = cie->first, j = fde->data;
962 i != cie->last && j != NULL;
963 i = i->next, j = j->next)
965 if (i->insn != j->insn)
969 case DW_CFA_advance_loc:
970 case DW_CFA_remember_state:
971 /* We reached the first advance/remember in the FDE,
972 but did not reach the end of the CIE list. */
977 if (i->u.ri.reg != j->u.ri.reg)
979 if (i->u.ri.offset != j->u.ri.offset)
983 case DW_CFA_register:
984 if (i->u.rr.reg1 != j->u.rr.reg1)
986 if (i->u.rr.reg2 != j->u.rr.reg2)
990 case DW_CFA_def_cfa_register:
992 case DW_CFA_undefined:
993 case DW_CFA_same_value:
994 if (i->u.r != j->u.r)
998 case DW_CFA_def_cfa_offset:
999 if (i->u.i != j->u.i)
1004 /* Don't bother matching these for now. */
1012 /* Success if we reached the end of the CIE list, and we've either
1013 run out of FDE entries or we've encountered an advance,
1014 remember, or escape. */
1017 || j->insn == DW_CFA_advance_loc
1018 || j->insn == DW_CFA_remember_state
1019 || j->insn == CFI_escape))
1028 cie = xmalloc (sizeof (struct cie_entry));
1029 cie->next = cie_root;
1031 cie->return_column = fde->return_column;
1032 cie->signal_frame = fde->signal_frame;
1033 cie->first = fde->data;
1035 for (i = cie->first; i ; i = i->next)
1036 if (i->insn == DW_CFA_advance_loc
1037 || i->insn == DW_CFA_remember_state
1038 || i->insn == CFI_escape)
1053 struct fde_entry *fde;
1054 int save_flag_traditional_format;
1058 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1059 cur_fde_data->end_address = cur_fde_data->start_address;
1062 if (all_fde_data == 0)
1065 /* Open .eh_frame section. */
1066 cfi_seg = subseg_new (".eh_frame", 0);
1067 bfd_set_section_flags (stdoutput, cfi_seg,
1068 SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY);
1069 subseg_set (cfi_seg, 0);
1070 record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
1072 /* Make sure check_eh_frame doesn't do anything with our output. */
1073 save_flag_traditional_format = flag_traditional_format;
1074 flag_traditional_format = 1;
1076 for (fde = all_fde_data; fde ; fde = fde->next)
1078 struct cfi_insn_data *first;
1079 struct cie_entry *cie;
1081 cie = select_cie_for_fde (fde, &first);
1082 output_fde (fde, cie, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1085 flag_traditional_format = save_flag_traditional_format;