1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright (C) 2003-2019 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 3, 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"
25 #include "dwarf2dbg.h"
27 #ifdef TARGET_USE_CFIPOP
29 /* By default, use difference expressions if DIFF_EXPR_OK is defined. */
30 #ifndef CFI_DIFF_EXPR_OK
32 # define CFI_DIFF_EXPR_OK 1
34 # define CFI_DIFF_EXPR_OK 0
38 #ifndef CFI_DIFF_LSDA_OK
39 #define CFI_DIFF_LSDA_OK CFI_DIFF_EXPR_OK
42 #if CFI_DIFF_EXPR_OK == 1 && CFI_DIFF_LSDA_OK == 0
43 # error "CFI_DIFF_EXPR_OK should imply CFI_DIFF_LSDA_OK"
46 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
47 of the CIE. Default to 1 if not otherwise specified. */
48 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
49 #define DWARF2_LINE_MIN_INSN_LENGTH 1
52 /* By default, use 32-bit relocations from .eh_frame into .text. */
53 #ifndef DWARF2_FDE_RELOC_SIZE
54 #define DWARF2_FDE_RELOC_SIZE 4
57 /* By default, use a read-only .eh_frame section. */
58 #ifndef DWARF2_EH_FRAME_READ_ONLY
59 #define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY
62 #ifndef EH_FRAME_ALIGNMENT
63 #define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
66 #ifndef tc_cfi_frame_initial_instructions
67 #define tc_cfi_frame_initial_instructions() ((void)0)
70 #ifndef tc_cfi_startproc
71 # define tc_cfi_startproc() ((void)0)
74 #ifndef tc_cfi_endproc
75 # define tc_cfi_endproc(fde) ((void) (fde))
78 #define EH_FRAME_LINKONCE (SUPPORT_FRAME_LINKONCE || compact_eh)
81 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit
84 #ifndef DWARF2_ADDR_SIZE
85 #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
88 #if MULTIPLE_FRAME_SECTIONS
89 #define CUR_SEG(structp) structp->cur_seg
90 #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg
91 #define HANDLED(structp) structp->handled
92 #define SET_HANDLED(structp, val) structp->handled = val
94 #define CUR_SEG(structp) NULL
95 #define SET_CUR_SEG(structp, seg) (void) (0 && seg)
96 #define HANDLED(structp) 0
97 #define SET_HANDLED(structp, val) (void) (0 && val)
100 #ifndef tc_cfi_reloc_for_encoding
101 #define tc_cfi_reloc_for_encoding(e) BFD_RELOC_NONE
104 /* Private segment collection list. */
105 struct dwcfi_seg_list
112 #ifdef SUPPORT_COMPACT_EH
113 static bfd_boolean compact_eh
;
118 static struct hash_control
*dwcfi_hash
;
120 /* Emit a single byte into the current segment. */
125 FRAG_APPEND_1_CHAR (byte
);
128 /* Emit a two-byte word into the current segment. */
133 md_number_to_chars (frag_more (2), data
, 2);
136 /* Emit a four byte word into the current segment. */
141 md_number_to_chars (frag_more (4), data
, 4);
144 /* Emit an unsigned "little-endian base 128" number. */
147 out_uleb128 (addressT value
)
149 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
152 /* Emit an unsigned "little-endian base 128" number. */
155 out_sleb128 (offsetT value
)
157 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
161 encoding_size (unsigned char encoding
)
163 if (encoding
== DW_EH_PE_omit
)
165 switch (encoding
& 0x7)
168 return bfd_get_arch_size (stdoutput
) == 64 ? 8 : 4;
169 case DW_EH_PE_udata2
:
171 case DW_EH_PE_udata4
:
173 case DW_EH_PE_udata8
:
180 /* Emit expression EXP in ENCODING. If EMIT_ENCODING is true, first
181 emit a byte containing ENCODING. */
184 emit_expr_encoded (expressionS
*exp
, int encoding
, bfd_boolean emit_encoding
)
186 unsigned int size
= encoding_size (encoding
);
187 bfd_reloc_code_real_type code
;
189 if (encoding
== DW_EH_PE_omit
)
195 code
= tc_cfi_reloc_for_encoding (encoding
);
196 if (code
!= BFD_RELOC_NONE
)
198 reloc_howto_type
*howto
= bfd_reloc_type_lookup (stdoutput
, code
);
199 char *p
= frag_more (size
);
200 gas_assert (size
== (unsigned) howto
->bitsize
/ 8);
201 md_number_to_chars (p
, 0, size
);
202 fix_new (frag_now
, p
- frag_now
->fr_literal
, size
, exp
->X_add_symbol
,
203 exp
->X_add_number
, howto
->pc_relative
, code
);
205 else if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
208 expressionS tmp
= *exp
;
209 tmp
.X_op
= O_subtract
;
210 tmp
.X_op_symbol
= symbol_temp_new_now ();
211 emit_expr (&tmp
, size
);
212 #elif defined (tc_cfi_emit_pcrel_expr)
213 tc_cfi_emit_pcrel_expr (exp
, size
);
219 emit_expr (exp
, size
);
222 /* Build based on segment the derived .debug_...
223 segment name containing origin segment's postfix name part. */
226 get_debugseg_name (segT seg
, const char *base_name
)
233 return concat (base_name
, NULL
);
235 name
= bfd_section_name (seg
);
237 if (name
== NULL
|| *name
== 0)
238 return concat (base_name
, NULL
);
240 dollar
= strchr (name
, '$');
241 dot
= strchr (name
+ 1, '.');
245 if (!strcmp (base_name
, ".eh_frame_entry")
246 && strcmp (name
, ".text") != 0)
247 return concat (base_name
, ".", name
, NULL
);
255 else if (dot
< dollar
)
260 return concat (base_name
, name
, NULL
);
263 /* Allocate a dwcfi_seg_list structure. */
265 static struct dwcfi_seg_list
*
266 alloc_debugseg_item (segT seg
, int subseg
, char *name
)
268 struct dwcfi_seg_list
*r
;
270 r
= (struct dwcfi_seg_list
*)
271 xmalloc (sizeof (struct dwcfi_seg_list
) + strlen (name
));
279 is_now_linkonce_segment (void)
284 if ((bfd_section_flags (now_seg
)
285 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
286 | SEC_LINK_DUPLICATES_ONE_ONLY
| SEC_LINK_DUPLICATES_SAME_SIZE
287 | SEC_LINK_DUPLICATES_SAME_CONTENTS
)) != 0)
292 /* Generate debug... segment with same linkonce properties
296 make_debug_seg (segT cseg
, char *name
, int sflags
)
298 segT save_seg
= now_seg
;
299 int save_subseg
= now_subseg
;
303 r
= subseg_new (name
, 0);
305 /* Check if code segment is marked as linked once. */
309 flags
= (bfd_section_flags (cseg
)
310 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
311 | SEC_LINK_DUPLICATES_ONE_ONLY
| SEC_LINK_DUPLICATES_SAME_SIZE
312 | SEC_LINK_DUPLICATES_SAME_CONTENTS
));
314 /* Add standard section flags. */
317 /* Apply possibly linked once flags to new generated segment, too. */
318 if (!bfd_set_section_flags (r
, flags
))
319 as_bad (_("bfd_set_section_flags: %s"),
320 bfd_errmsg (bfd_get_error ()));
322 /* Restore to previous segment. */
323 if (save_seg
!= NULL
)
324 subseg_set (save_seg
, save_subseg
);
329 dwcfi_hash_insert (const char *name
, struct dwcfi_seg_list
*item
)
331 const char *error_string
;
333 if ((error_string
= hash_jam (dwcfi_hash
, name
, (char *) item
)))
334 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
338 static struct dwcfi_seg_list
*
339 dwcfi_hash_find (char *name
)
341 return (struct dwcfi_seg_list
*) hash_find (dwcfi_hash
, name
);
344 static struct dwcfi_seg_list
*
345 dwcfi_hash_find_or_make (segT cseg
, const char *base_name
, int flags
)
347 struct dwcfi_seg_list
*item
;
350 /* Initialize dwcfi_hash once. */
352 dwcfi_hash
= hash_new ();
354 name
= get_debugseg_name (cseg
, base_name
);
356 item
= dwcfi_hash_find (name
);
359 item
= alloc_debugseg_item (make_debug_seg (cseg
, name
, flags
), 0, name
);
361 dwcfi_hash_insert (item
->seg_name
, item
);
369 /* ??? Share this with dwarf2cfg.c. */
370 #ifndef TC_DWARF2_EMIT_OFFSET
371 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
373 /* Create an offset to .dwarf2_*. */
376 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
381 exp
.X_add_symbol
= symbol
;
382 exp
.X_add_number
= 0;
383 emit_expr (&exp
, size
);
387 struct cfi_escape_data
389 struct cfi_escape_data
*next
;
395 struct cie_entry
*next
;
396 #if MULTIPLE_FRAME_SECTIONS
399 symbolS
*start_address
;
400 unsigned int return_column
;
401 unsigned int signal_frame
;
402 unsigned char fde_encoding
;
403 unsigned char per_encoding
;
404 unsigned char lsda_encoding
;
405 expressionS personality
;
406 #ifdef tc_cie_entry_extras
409 struct cfi_insn_data
*first
, *last
;
412 /* List of FDE entries. */
414 struct fde_entry
*all_fde_data
;
415 static struct fde_entry
**last_fde_data
= &all_fde_data
;
417 /* List of CIEs so that they could be reused. */
418 static struct cie_entry
*cie_root
;
420 /* Construct a new FDE structure and add it to the end of the fde list. */
422 static struct fde_entry
*
423 alloc_fde_entry (void)
425 struct fde_entry
*fde
= XCNEW (struct fde_entry
);
427 frchain_now
->frch_cfi_data
= XCNEW (struct frch_cfi_data
);
428 frchain_now
->frch_cfi_data
->cur_fde_data
= fde
;
429 *last_fde_data
= fde
;
430 last_fde_data
= &fde
->next
;
431 SET_CUR_SEG (fde
, is_now_linkonce_segment ());
432 SET_HANDLED (fde
, 0);
433 fde
->last
= &fde
->data
;
434 fde
->return_column
= DWARF2_DEFAULT_RETURN_COLUMN
;
435 fde
->per_encoding
= DW_EH_PE_omit
;
436 fde
->lsda_encoding
= DW_EH_PE_omit
;
437 fde
->eh_header_type
= EH_COMPACT_UNKNOWN
;
438 #ifdef tc_fde_entry_init_extra
439 tc_fde_entry_init_extra (fde
)
445 /* The following functions are available for a backend to construct its
446 own unwind information, usually from legacy unwind directives. */
448 /* Construct a new INSN structure and add it to the end of the insn list
449 for the currently active FDE. */
451 static bfd_boolean cfi_sections_set
= FALSE
;
452 static int cfi_sections
= CFI_EMIT_eh_frame
;
453 int all_cfi_sections
= 0;
454 static struct fde_entry
*last_fde
;
456 static struct cfi_insn_data
*
457 alloc_cfi_insn_data (void)
459 struct cfi_insn_data
*insn
= XCNEW (struct cfi_insn_data
);
460 struct fde_entry
*cur_fde_data
= frchain_now
->frch_cfi_data
->cur_fde_data
;
462 *cur_fde_data
->last
= insn
;
463 cur_fde_data
->last
= &insn
->next
;
464 SET_CUR_SEG (insn
, is_now_linkonce_segment ());
468 /* Construct a new FDE structure that begins at LABEL. */
471 cfi_new_fde (symbolS
*label
)
473 struct fde_entry
*fde
= alloc_fde_entry ();
474 fde
->start_address
= label
;
475 frchain_now
->frch_cfi_data
->last_address
= label
;
478 /* End the currently open FDE. */
481 cfi_end_fde (symbolS
*label
)
483 frchain_now
->frch_cfi_data
->cur_fde_data
->end_address
= label
;
484 free (frchain_now
->frch_cfi_data
);
485 frchain_now
->frch_cfi_data
= NULL
;
488 /* Set the return column for the current FDE. */
491 cfi_set_return_column (unsigned regno
)
493 frchain_now
->frch_cfi_data
->cur_fde_data
->return_column
= regno
;
497 cfi_set_sections (void)
499 frchain_now
->frch_cfi_data
->cur_fde_data
->sections
= all_cfi_sections
;
500 cfi_sections_set
= TRUE
;
503 /* Universal functions to store new instructions. */
506 cfi_add_CFA_insn (int insn
)
508 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
510 insn_ptr
->insn
= insn
;
514 cfi_add_CFA_insn_reg (int insn
, unsigned regno
)
516 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
518 insn_ptr
->insn
= insn
;
519 insn_ptr
->u
.r
= regno
;
523 cfi_add_CFA_insn_offset (int insn
, offsetT offset
)
525 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
527 insn_ptr
->insn
= insn
;
528 insn_ptr
->u
.i
= offset
;
532 cfi_add_CFA_insn_reg_reg (int insn
, unsigned reg1
, unsigned reg2
)
534 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
536 insn_ptr
->insn
= insn
;
537 insn_ptr
->u
.rr
.reg1
= reg1
;
538 insn_ptr
->u
.rr
.reg2
= reg2
;
542 cfi_add_CFA_insn_reg_offset (int insn
, unsigned regno
, offsetT offset
)
544 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
546 insn_ptr
->insn
= insn
;
547 insn_ptr
->u
.ri
.reg
= regno
;
548 insn_ptr
->u
.ri
.offset
= offset
;
551 /* Add a CFI insn to advance the PC from the last address to LABEL. */
554 cfi_add_advance_loc (symbolS
*label
)
556 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
558 insn
->insn
= DW_CFA_advance_loc
;
559 insn
->u
.ll
.lab1
= frchain_now
->frch_cfi_data
->last_address
;
560 insn
->u
.ll
.lab2
= label
;
562 frchain_now
->frch_cfi_data
->last_address
= label
;
565 /* Add a CFI insn to label the current position in the CFI segment. */
568 cfi_add_label (const char *name
)
570 unsigned int len
= strlen (name
) + 1;
571 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
573 insn
->insn
= CFI_label
;
574 obstack_grow (¬es
, name
, len
);
575 insn
->u
.sym_name
= (char *) obstack_finish (¬es
);
578 /* Add a DW_CFA_offset record to the CFI data. */
581 cfi_add_CFA_offset (unsigned regno
, offsetT offset
)
583 unsigned int abs_data_align
;
585 gas_assert (DWARF2_CIE_DATA_ALIGNMENT
!= 0);
586 cfi_add_CFA_insn_reg_offset (DW_CFA_offset
, regno
, offset
);
588 abs_data_align
= (DWARF2_CIE_DATA_ALIGNMENT
< 0
589 ? -DWARF2_CIE_DATA_ALIGNMENT
: DWARF2_CIE_DATA_ALIGNMENT
);
590 if (offset
% abs_data_align
)
591 as_bad (_("register save offset not a multiple of %u"), abs_data_align
);
594 /* Add a DW_CFA_val_offset record to the CFI data. */
597 cfi_add_CFA_val_offset (unsigned regno
, offsetT offset
)
599 unsigned int abs_data_align
;
601 gas_assert (DWARF2_CIE_DATA_ALIGNMENT
!= 0);
602 cfi_add_CFA_insn_reg_offset (DW_CFA_val_offset
, regno
, offset
);
604 abs_data_align
= (DWARF2_CIE_DATA_ALIGNMENT
< 0
605 ? -DWARF2_CIE_DATA_ALIGNMENT
: DWARF2_CIE_DATA_ALIGNMENT
);
606 if (offset
% abs_data_align
)
607 as_bad (_("register save offset not a multiple of %u"), abs_data_align
);
610 /* Add a DW_CFA_def_cfa record to the CFI data. */
613 cfi_add_CFA_def_cfa (unsigned regno
, offsetT offset
)
615 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa
, regno
, offset
);
616 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
619 /* Add a DW_CFA_register record to the CFI data. */
622 cfi_add_CFA_register (unsigned reg1
, unsigned reg2
)
624 cfi_add_CFA_insn_reg_reg (DW_CFA_register
, reg1
, reg2
);
627 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
630 cfi_add_CFA_def_cfa_register (unsigned regno
)
632 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register
, regno
);
635 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
638 cfi_add_CFA_def_cfa_offset (offsetT offset
)
640 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset
, offset
);
641 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
645 cfi_add_CFA_restore (unsigned regno
)
647 cfi_add_CFA_insn_reg (DW_CFA_restore
, regno
);
651 cfi_add_CFA_undefined (unsigned regno
)
653 cfi_add_CFA_insn_reg (DW_CFA_undefined
, regno
);
657 cfi_add_CFA_same_value (unsigned regno
)
659 cfi_add_CFA_insn_reg (DW_CFA_same_value
, regno
);
663 cfi_add_CFA_remember_state (void)
665 struct cfa_save_data
*p
;
667 cfi_add_CFA_insn (DW_CFA_remember_state
);
669 p
= XNEW (struct cfa_save_data
);
670 p
->cfa_offset
= frchain_now
->frch_cfi_data
->cur_cfa_offset
;
671 p
->next
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
672 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
;
676 cfi_add_CFA_restore_state (void)
678 struct cfa_save_data
*p
;
680 cfi_add_CFA_insn (DW_CFA_restore_state
);
682 p
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
685 frchain_now
->frch_cfi_data
->cur_cfa_offset
= p
->cfa_offset
;
686 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
->next
;
690 as_bad (_("CFI state restore without previous remember"));
694 /* Parse CFI assembler directives. */
696 static void dot_cfi (int);
697 static void dot_cfi_escape (int);
698 static void dot_cfi_sections (int);
699 static void dot_cfi_startproc (int);
700 static void dot_cfi_endproc (int);
701 static void dot_cfi_fde_data (int);
702 static void dot_cfi_personality (int);
703 static void dot_cfi_personality_id (int);
704 static void dot_cfi_lsda (int);
705 static void dot_cfi_val_encoded_addr (int);
706 static void dot_cfi_inline_lsda (int);
707 static void dot_cfi_label (int);
709 const pseudo_typeS cfi_pseudo_table
[] =
711 { "cfi_sections", dot_cfi_sections
, 0 },
712 { "cfi_startproc", dot_cfi_startproc
, 0 },
713 { "cfi_endproc", dot_cfi_endproc
, 0 },
714 { "cfi_fde_data", dot_cfi_fde_data
, 0 },
715 { "cfi_def_cfa", dot_cfi
, DW_CFA_def_cfa
},
716 { "cfi_def_cfa_register", dot_cfi
, DW_CFA_def_cfa_register
},
717 { "cfi_def_cfa_offset", dot_cfi
, DW_CFA_def_cfa_offset
},
718 { "cfi_adjust_cfa_offset", dot_cfi
, CFI_adjust_cfa_offset
},
719 { "cfi_offset", dot_cfi
, DW_CFA_offset
},
720 { "cfi_rel_offset", dot_cfi
, CFI_rel_offset
},
721 { "cfi_register", dot_cfi
, DW_CFA_register
},
722 { "cfi_return_column", dot_cfi
, CFI_return_column
},
723 { "cfi_restore", dot_cfi
, DW_CFA_restore
},
724 { "cfi_undefined", dot_cfi
, DW_CFA_undefined
},
725 { "cfi_same_value", dot_cfi
, DW_CFA_same_value
},
726 { "cfi_remember_state", dot_cfi
, DW_CFA_remember_state
},
727 { "cfi_restore_state", dot_cfi
, DW_CFA_restore_state
},
728 { "cfi_window_save", dot_cfi
, DW_CFA_GNU_window_save
},
729 { "cfi_escape", dot_cfi_escape
, 0 },
730 { "cfi_signal_frame", dot_cfi
, CFI_signal_frame
},
731 { "cfi_personality", dot_cfi_personality
, 0 },
732 { "cfi_personality_id", dot_cfi_personality_id
, 0 },
733 { "cfi_lsda", dot_cfi_lsda
, 0 },
734 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr
, 0 },
735 { "cfi_inline_lsda", dot_cfi_inline_lsda
, 0 },
736 { "cfi_label", dot_cfi_label
, 0 },
737 { "cfi_val_offset", dot_cfi
, DW_CFA_val_offset
},
742 cfi_parse_separator (void)
745 if (*input_line_pointer
== ',')
746 input_line_pointer
++;
748 as_bad (_("missing separator"));
751 #ifndef tc_parse_to_dw2regnum
753 tc_parse_to_dw2regnum (expressionS
*exp
)
755 # ifdef tc_regname_to_dw2regnum
757 if (is_name_beginner (*input_line_pointer
)
758 || (*input_line_pointer
== '%'
759 && is_name_beginner (*++input_line_pointer
)))
763 c
= get_symbol_name (& name
);
765 exp
->X_op
= O_constant
;
766 exp
->X_add_number
= tc_regname_to_dw2regnum (name
);
768 restore_line_pointer (c
);
772 expression_and_evaluate (exp
);
782 tc_parse_to_dw2regnum (&exp
);
787 regno
= exp
.X_add_number
;
797 as_bad (_("bad register expression"));
805 cfi_parse_const (void)
807 return get_absolute_expression ();
816 if (frchain_now
->frch_cfi_data
== NULL
)
818 as_bad (_("CFI instruction used without previous .cfi_startproc"));
819 ignore_rest_of_line ();
823 /* If the last address was not at the current PC, advance to current. */
824 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
825 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
827 cfi_add_advance_loc (symbol_temp_new_now ());
832 reg1
= cfi_parse_reg ();
833 cfi_parse_separator ();
834 offset
= cfi_parse_const ();
835 cfi_add_CFA_offset (reg1
, offset
);
838 case DW_CFA_val_offset
:
839 reg1
= cfi_parse_reg ();
840 cfi_parse_separator ();
841 offset
= cfi_parse_const ();
842 cfi_add_CFA_val_offset (reg1
, offset
);
846 reg1
= cfi_parse_reg ();
847 cfi_parse_separator ();
848 offset
= cfi_parse_const ();
849 cfi_add_CFA_offset (reg1
,
850 offset
- frchain_now
->frch_cfi_data
->cur_cfa_offset
);
854 reg1
= cfi_parse_reg ();
855 cfi_parse_separator ();
856 offset
= cfi_parse_const ();
857 cfi_add_CFA_def_cfa (reg1
, offset
);
860 case DW_CFA_register
:
861 reg1
= cfi_parse_reg ();
862 cfi_parse_separator ();
863 reg2
= cfi_parse_reg ();
864 cfi_add_CFA_register (reg1
, reg2
);
867 case DW_CFA_def_cfa_register
:
868 reg1
= cfi_parse_reg ();
869 cfi_add_CFA_def_cfa_register (reg1
);
872 case DW_CFA_def_cfa_offset
:
873 offset
= cfi_parse_const ();
874 cfi_add_CFA_def_cfa_offset (offset
);
877 case CFI_adjust_cfa_offset
:
878 offset
= cfi_parse_const ();
879 cfi_add_CFA_def_cfa_offset (frchain_now
->frch_cfi_data
->cur_cfa_offset
886 reg1
= cfi_parse_reg ();
887 cfi_add_CFA_restore (reg1
);
889 if (*input_line_pointer
!= ',')
891 ++input_line_pointer
;
895 case DW_CFA_undefined
:
898 reg1
= cfi_parse_reg ();
899 cfi_add_CFA_undefined (reg1
);
901 if (*input_line_pointer
!= ',')
903 ++input_line_pointer
;
907 case DW_CFA_same_value
:
908 reg1
= cfi_parse_reg ();
909 cfi_add_CFA_same_value (reg1
);
912 case CFI_return_column
:
913 reg1
= cfi_parse_reg ();
914 cfi_set_return_column (reg1
);
917 case DW_CFA_remember_state
:
918 cfi_add_CFA_remember_state ();
921 case DW_CFA_restore_state
:
922 cfi_add_CFA_restore_state ();
925 case DW_CFA_GNU_window_save
:
926 cfi_add_CFA_insn (DW_CFA_GNU_window_save
);
929 case CFI_signal_frame
:
930 frchain_now
->frch_cfi_data
->cur_fde_data
->signal_frame
= 1;
937 demand_empty_rest_of_line ();
941 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED
)
943 struct cfi_escape_data
*head
, **tail
, *e
;
944 struct cfi_insn_data
*insn
;
946 if (frchain_now
->frch_cfi_data
== NULL
)
948 as_bad (_("CFI instruction used without previous .cfi_startproc"));
949 ignore_rest_of_line ();
953 /* If the last address was not at the current PC, advance to current. */
954 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
955 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
957 cfi_add_advance_loc (symbol_temp_new_now ());
962 e
= XNEW (struct cfi_escape_data
);
963 do_parse_cons_expression (&e
->exp
, 1);
967 while (*input_line_pointer
++ == ',');
970 insn
= alloc_cfi_insn_data ();
971 insn
->insn
= CFI_escape
;
974 --input_line_pointer
;
975 demand_empty_rest_of_line ();
979 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED
)
981 struct fde_entry
*fde
;
984 if (frchain_now
->frch_cfi_data
== NULL
)
986 as_bad (_("CFI instruction used without previous .cfi_startproc"));
987 ignore_rest_of_line ();
991 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
992 encoding
= cfi_parse_const ();
993 if (encoding
== DW_EH_PE_omit
)
995 demand_empty_rest_of_line ();
996 fde
->per_encoding
= encoding
;
1000 if ((encoding
& 0xff) != encoding
1001 || ((((encoding
& 0x70) != 0
1002 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1003 && (encoding
& 0x70) != DW_EH_PE_pcrel
1006 /* leb128 can be handled, but does something actually need it? */
1007 || (encoding
& 7) == DW_EH_PE_uleb128
1008 || (encoding
& 7) > DW_EH_PE_udata8
)
1009 && tc_cfi_reloc_for_encoding (encoding
) == BFD_RELOC_NONE
))
1011 as_bad (_("invalid or unsupported encoding in .cfi_personality"));
1012 ignore_rest_of_line ();
1016 if (*input_line_pointer
++ != ',')
1018 as_bad (_(".cfi_personality requires encoding and symbol arguments"));
1019 ignore_rest_of_line ();
1023 expression_and_evaluate (&fde
->personality
);
1024 switch (fde
->personality
.X_op
)
1029 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1030 encoding
= DW_EH_PE_omit
;
1033 encoding
= DW_EH_PE_omit
;
1037 fde
->per_encoding
= encoding
;
1039 if (encoding
== DW_EH_PE_omit
)
1041 as_bad (_("wrong second argument to .cfi_personality"));
1042 ignore_rest_of_line ();
1046 demand_empty_rest_of_line ();
1050 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED
)
1052 struct fde_entry
*fde
;
1055 if (frchain_now
->frch_cfi_data
== NULL
)
1057 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1058 ignore_rest_of_line ();
1062 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1063 encoding
= cfi_parse_const ();
1064 if (encoding
== DW_EH_PE_omit
)
1066 demand_empty_rest_of_line ();
1067 fde
->lsda_encoding
= encoding
;
1071 if ((encoding
& 0xff) != encoding
1072 || ((((encoding
& 0x70) != 0
1073 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
1074 && (encoding
& 0x70) != DW_EH_PE_pcrel
1077 /* leb128 can be handled, but does something actually need it? */
1078 || (encoding
& 7) == DW_EH_PE_uleb128
1079 || (encoding
& 7) > DW_EH_PE_udata8
)
1080 && tc_cfi_reloc_for_encoding (encoding
) == BFD_RELOC_NONE
))
1082 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1083 ignore_rest_of_line ();
1087 if (*input_line_pointer
++ != ',')
1089 as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
1090 ignore_rest_of_line ();
1094 fde
->lsda_encoding
= encoding
;
1096 expression_and_evaluate (&fde
->lsda
);
1097 switch (fde
->lsda
.X_op
)
1102 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1103 encoding
= DW_EH_PE_omit
;
1106 encoding
= DW_EH_PE_omit
;
1110 fde
->lsda_encoding
= encoding
;
1112 if (encoding
== DW_EH_PE_omit
)
1114 as_bad (_("wrong second argument to .cfi_lsda"));
1115 ignore_rest_of_line ();
1119 demand_empty_rest_of_line ();
1123 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED
)
1125 struct cfi_insn_data
*insn_ptr
;
1128 if (frchain_now
->frch_cfi_data
== NULL
)
1130 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1131 ignore_rest_of_line ();
1135 /* If the last address was not at the current PC, advance to current. */
1136 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
1137 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
1138 != frag_now_fix ()))
1139 cfi_add_advance_loc (symbol_temp_new_now ());
1141 insn_ptr
= alloc_cfi_insn_data ();
1142 insn_ptr
->insn
= CFI_val_encoded_addr
;
1144 insn_ptr
->u
.ea
.reg
= cfi_parse_reg ();
1146 cfi_parse_separator ();
1147 encoding
= cfi_parse_const ();
1148 if ((encoding
& 0xff) != encoding
1149 || ((encoding
& 0x70) != 0
1150 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1151 && (encoding
& 0x70) != DW_EH_PE_pcrel
1154 /* leb128 can be handled, but does something actually need it? */
1155 || (encoding
& 7) == DW_EH_PE_uleb128
1156 || (encoding
& 7) > DW_EH_PE_udata8
)
1158 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1159 encoding
= DW_EH_PE_omit
;
1162 cfi_parse_separator ();
1163 expression_and_evaluate (&insn_ptr
->u
.ea
.exp
);
1164 switch (insn_ptr
->u
.ea
.exp
.X_op
)
1169 if ((encoding
& 0x70) != DW_EH_PE_pcrel
)
1173 encoding
= DW_EH_PE_omit
;
1177 insn_ptr
->u
.ea
.encoding
= encoding
;
1178 if (encoding
== DW_EH_PE_omit
)
1180 as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1181 ignore_rest_of_line ();
1185 demand_empty_rest_of_line ();
1189 dot_cfi_label (int ignored ATTRIBUTE_UNUSED
)
1193 if (frchain_now
->frch_cfi_data
== NULL
)
1195 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1196 ignore_rest_of_line ();
1200 name
= read_symbol_name ();
1204 /* If the last address was not at the current PC, advance to current. */
1205 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
1206 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
1207 != frag_now_fix ()))
1208 cfi_add_advance_loc (symbol_temp_new_now ());
1210 cfi_add_label (name
);
1213 demand_empty_rest_of_line ();
1217 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED
)
1222 if (is_name_beginner (*input_line_pointer
) || *input_line_pointer
== '"')
1228 saved_ilp
= input_line_pointer
;
1229 c
= get_symbol_name (& name
);
1231 if (strncmp (name
, ".eh_frame", sizeof ".eh_frame") == 0
1233 sections
|= CFI_EMIT_eh_frame
;
1234 else if (strncmp (name
, ".debug_frame", sizeof ".debug_frame") == 0)
1235 sections
|= CFI_EMIT_debug_frame
;
1236 #if SUPPORT_COMPACT_EH
1237 else if (strncmp (name
, ".eh_frame_entry",
1238 sizeof ".eh_frame_entry") == 0)
1241 sections
|= CFI_EMIT_eh_frame_compact
;
1244 #ifdef tc_cfi_section_name
1245 else if (strcmp (name
, tc_cfi_section_name
) == 0)
1246 sections
|= CFI_EMIT_target
;
1250 *input_line_pointer
= c
;
1251 input_line_pointer
= saved_ilp
;
1255 *input_line_pointer
= c
;
1256 SKIP_WHITESPACE_AFTER_NAME ();
1257 if (*input_line_pointer
== ',')
1259 name
= input_line_pointer
++;
1261 if (!is_name_beginner (*input_line_pointer
)
1262 && *input_line_pointer
!= '"')
1264 input_line_pointer
= name
;
1268 else if (is_name_beginner (*input_line_pointer
)
1269 || *input_line_pointer
== '"')
1273 demand_empty_rest_of_line ();
1274 if (cfi_sections_set
1275 && (sections
& (CFI_EMIT_eh_frame
| CFI_EMIT_eh_frame_compact
))
1276 && ((cfi_sections
& (CFI_EMIT_eh_frame
| CFI_EMIT_eh_frame_compact
))
1277 != (sections
& (CFI_EMIT_eh_frame
| CFI_EMIT_eh_frame_compact
))))
1278 as_bad (_("inconsistent uses of .cfi_sections"));
1279 cfi_sections
= sections
;
1283 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED
)
1287 if (frchain_now
->frch_cfi_data
!= NULL
)
1289 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1290 ignore_rest_of_line ();
1294 cfi_new_fde (symbol_temp_new_now ());
1297 if (is_name_beginner (*input_line_pointer
) || *input_line_pointer
== '"')
1299 char * saved_ilp
= input_line_pointer
;
1302 c
= get_symbol_name (& name
);
1304 if (strcmp (name
, "simple") == 0)
1307 restore_line_pointer (c
);
1310 input_line_pointer
= saved_ilp
;
1312 demand_empty_rest_of_line ();
1314 cfi_sections_set
= TRUE
;
1315 all_cfi_sections
|= cfi_sections
;
1316 cfi_set_sections ();
1317 frchain_now
->frch_cfi_data
->cur_cfa_offset
= 0;
1319 tc_cfi_frame_initial_instructions ();
1321 if ((cfi_sections
& CFI_EMIT_target
) != 0)
1322 tc_cfi_startproc ();
1326 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED
)
1328 if (frchain_now
->frch_cfi_data
== NULL
)
1330 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1331 ignore_rest_of_line ();
1335 last_fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1337 cfi_end_fde (symbol_temp_new_now ());
1339 demand_empty_rest_of_line ();
1341 cfi_sections_set
= TRUE
;
1342 if ((cfi_sections
& CFI_EMIT_target
) != 0)
1343 tc_cfi_endproc (last_fde
);
1347 get_cfi_seg (segT cseg
, const char *base
, flagword flags
, int align
)
1349 /* Exclude .debug_frame sections for Compact EH. */
1350 if (SUPPORT_FRAME_LINKONCE
|| ((flags
& SEC_DEBUGGING
) == 0 && compact_eh
))
1352 struct dwcfi_seg_list
*l
;
1354 l
= dwcfi_hash_find_or_make (cseg
, base
, flags
);
1357 subseg_set (cseg
, l
->subseg
);
1361 cseg
= subseg_new (base
, 0);
1362 bfd_set_section_flags (cseg
, flags
);
1364 record_alignment (cseg
, align
);
1368 #if SUPPORT_COMPACT_EH
1370 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED
)
1372 struct fde_entry
*fde
;
1374 if (frchain_now
->frch_cfi_data
== NULL
)
1376 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1377 ignore_rest_of_line ();
1381 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1382 fde
->personality_id
= cfi_parse_const ();
1383 demand_empty_rest_of_line ();
1385 if (fde
->personality_id
== 0 || fde
->personality_id
> 3)
1387 as_bad (_("wrong argument to .cfi_personality_id"));
1393 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED
)
1395 if (frchain_now
->frch_cfi_data
== NULL
)
1397 as_bad (_(".cfi_fde_data without corresponding .cfi_startproc"));
1398 ignore_rest_of_line ();
1402 last_fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1404 cfi_sections_set
= TRUE
;
1405 if ((cfi_sections
& CFI_EMIT_target
) != 0
1406 || (cfi_sections
& CFI_EMIT_eh_frame_compact
) != 0)
1408 struct cfi_escape_data
*head
, **tail
, *e
;
1412 if (!is_it_end_of_statement ())
1417 e
= XNEW (struct cfi_escape_data
);
1418 do_parse_cons_expression (&e
->exp
, 1);
1423 while (*input_line_pointer
++ == ',');
1424 --input_line_pointer
;
1428 if (last_fde
->lsda_encoding
!= DW_EH_PE_omit
)
1429 last_fde
->eh_header_type
= EH_COMPACT_HAS_LSDA
;
1430 else if (num_ops
<= 3 && last_fde
->per_encoding
== DW_EH_PE_omit
)
1431 last_fde
->eh_header_type
= EH_COMPACT_INLINE
;
1433 last_fde
->eh_header_type
= EH_COMPACT_OUTLINE
;
1435 if (last_fde
->eh_header_type
== EH_COMPACT_INLINE
)
1438 last_fde
->eh_data_size
= num_ops
;
1439 last_fde
->eh_data
= XNEWVEC (bfd_byte
, num_ops
);
1445 last_fde
->eh_data
[num_ops
++] = e
->exp
.X_add_number
;
1448 if (last_fde
->eh_header_type
== EH_COMPACT_INLINE
)
1450 last_fde
->eh_data
[num_ops
++] = tc_compact_eh_opcode_stop
;
1453 demand_empty_rest_of_line ();
1456 /* Function to emit the compact unwinding opcodes stored in the
1457 fde's eh_data field. The end of the opcode data will be
1458 padded to the value in align. */
1461 output_compact_unwind_data (struct fde_entry
*fde
, int align
)
1463 int data_size
= fde
->eh_data_size
+ 2;
1468 fde
->eh_loc
= symbol_temp_new_now ();
1471 if (fde
->personality_id
!= 0)
1472 *p
= fde
->personality_id
;
1473 else if (fde
->per_encoding
!= DW_EH_PE_omit
)
1476 emit_expr_encoded (&fde
->personality
, fde
->per_encoding
, FALSE
);
1477 data_size
+= encoding_size (fde
->per_encoding
);
1482 amask
= (1 << align
) - 1;
1483 align_padding
= ((data_size
+ amask
) & ~amask
) - data_size
;
1485 p
= frag_more (fde
->eh_data_size
+ 1 + align_padding
);
1486 memcpy (p
, fde
->eh_data
, fde
->eh_data_size
);
1487 p
+= fde
->eh_data_size
;
1489 while (align_padding
-- > 0)
1490 *(p
++) = tc_compact_eh_opcode_pad
;
1492 *(p
++) = tc_compact_eh_opcode_stop
;
1493 fde
->eh_header_type
= EH_COMPACT_OUTLINE_DONE
;
1496 /* Handle the .cfi_inline_lsda directive. */
1498 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED
)
1502 long max_alignment
= 28;
1506 as_bad (_("unexpected .cfi_inline_lsda"));
1507 ignore_rest_of_line ();
1511 if ((last_fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
1513 as_bad (_(".cfi_inline_lsda not valid for this frame"));
1514 ignore_rest_of_line ();
1518 if (last_fde
->eh_header_type
!= EH_COMPACT_UNKNOWN
1519 && last_fde
->eh_header_type
!= EH_COMPACT_HAS_LSDA
)
1521 as_bad (_(".cfi_inline_lsda seen for frame without .cfi_lsda"));
1522 ignore_rest_of_line ();
1526 #ifdef md_flush_pending_output
1527 md_flush_pending_output ();
1530 align
= get_absolute_expression ();
1531 if (align
> max_alignment
)
1533 align
= max_alignment
;
1534 as_bad (_("Alignment too large: %d. assumed."), align
);
1538 as_warn (_("Alignment negative: 0 assumed."));
1542 demand_empty_rest_of_line ();
1543 ccseg
= CUR_SEG (last_fde
);
1545 /* Open .gnu_extab section. */
1546 get_cfi_seg (ccseg
, ".gnu_extab",
1547 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
1548 | DWARF2_EH_FRAME_READ_ONLY
),
1551 frag_align (align
, 0, 0);
1552 record_alignment (now_seg
, align
);
1553 if (last_fde
->eh_header_type
== EH_COMPACT_HAS_LSDA
)
1554 output_compact_unwind_data (last_fde
, align
);
1560 #else /* !SUPPORT_COMPACT_EH */
1562 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED
)
1564 as_bad (_(".cfi_inline_lsda is not supported for this target"));
1565 ignore_rest_of_line ();
1569 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED
)
1571 as_bad (_(".cfi_fde_data is not supported for this target"));
1572 ignore_rest_of_line ();
1576 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED
)
1578 as_bad (_(".cfi_personality_id is not supported for this target"));
1579 ignore_rest_of_line ();
1584 output_cfi_insn (struct cfi_insn_data
*insn
)
1591 case DW_CFA_advance_loc
:
1593 symbolS
*from
= insn
->u
.ll
.lab1
;
1594 symbolS
*to
= insn
->u
.ll
.lab2
;
1596 if (symbol_get_frag (to
) == symbol_get_frag (from
))
1598 addressT delta
= S_GET_VALUE (to
) - S_GET_VALUE (from
);
1599 addressT scaled
= delta
/ DWARF2_LINE_MIN_INSN_LENGTH
;
1603 else if (scaled
<= 0x3F)
1604 out_one (DW_CFA_advance_loc
+ scaled
);
1605 else if (scaled
<= 0xFF)
1607 out_one (DW_CFA_advance_loc1
);
1610 else if (scaled
<= 0xFFFF)
1612 out_one (DW_CFA_advance_loc2
);
1617 out_one (DW_CFA_advance_loc4
);
1625 exp
.X_op
= O_subtract
;
1626 exp
.X_add_symbol
= to
;
1627 exp
.X_op_symbol
= from
;
1628 exp
.X_add_number
= 0;
1630 /* The code in ehopt.c expects that one byte of the encoding
1631 is already allocated to the frag. This comes from the way
1632 that it scans the .eh_frame section looking first for the
1633 .byte DW_CFA_advance_loc4. Call frag_grow with the sum of
1634 room needed by frag_more and frag_var to preallocate space
1635 ensuring that the DW_CFA_advance_loc4 is in the fixed part
1636 of the rs_cfa frag, so that the relax machinery can remove
1637 the advance_loc should it advance by zero. */
1639 *frag_more (1) = DW_CFA_advance_loc4
;
1641 frag_var (rs_cfa
, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH
<< 3,
1642 make_expr_symbol (&exp
), frag_now_fix () - 1,
1648 case DW_CFA_def_cfa
:
1649 offset
= insn
->u
.ri
.offset
;
1652 out_one (DW_CFA_def_cfa_sf
);
1653 out_uleb128 (insn
->u
.ri
.reg
);
1654 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1658 out_one (DW_CFA_def_cfa
);
1659 out_uleb128 (insn
->u
.ri
.reg
);
1660 out_uleb128 (offset
);
1664 case DW_CFA_def_cfa_register
:
1665 case DW_CFA_undefined
:
1666 case DW_CFA_same_value
:
1667 out_one (insn
->insn
);
1668 out_uleb128 (insn
->u
.r
);
1671 case DW_CFA_def_cfa_offset
:
1675 out_one (DW_CFA_def_cfa_offset_sf
);
1676 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1680 out_one (DW_CFA_def_cfa_offset
);
1681 out_uleb128 (offset
);
1685 case DW_CFA_restore
:
1689 out_one (DW_CFA_restore
+ regno
);
1693 out_one (DW_CFA_restore_extended
);
1694 out_uleb128 (regno
);
1699 regno
= insn
->u
.ri
.reg
;
1700 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
1703 out_one (DW_CFA_offset_extended_sf
);
1704 out_uleb128 (regno
);
1705 out_sleb128 (offset
);
1707 else if (regno
<= 0x3F)
1709 out_one (DW_CFA_offset
+ regno
);
1710 out_uleb128 (offset
);
1714 out_one (DW_CFA_offset_extended
);
1715 out_uleb128 (regno
);
1716 out_uleb128 (offset
);
1720 case DW_CFA_val_offset
:
1721 regno
= insn
->u
.ri
.reg
;
1722 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
1725 out_one (DW_CFA_val_offset_sf
);
1726 out_uleb128 (regno
);
1727 out_sleb128 (offset
);
1731 out_one (DW_CFA_val_offset
);
1732 out_uleb128 (regno
);
1733 out_uleb128 (offset
);
1737 case DW_CFA_register
:
1738 out_one (DW_CFA_register
);
1739 out_uleb128 (insn
->u
.rr
.reg1
);
1740 out_uleb128 (insn
->u
.rr
.reg2
);
1743 case DW_CFA_remember_state
:
1744 case DW_CFA_restore_state
:
1745 out_one (insn
->insn
);
1748 case DW_CFA_GNU_window_save
:
1749 out_one (DW_CFA_GNU_window_save
);
1754 struct cfi_escape_data
*e
;
1755 for (e
= insn
->u
.esc
; e
; e
= e
->next
)
1756 emit_expr (&e
->exp
, 1);
1760 case CFI_val_encoded_addr
:
1762 unsigned encoding
= insn
->u
.ea
.encoding
;
1765 if (encoding
== DW_EH_PE_omit
)
1767 out_one (DW_CFA_val_expression
);
1768 out_uleb128 (insn
->u
.ea
.reg
);
1770 switch (encoding
& 0x7)
1772 case DW_EH_PE_absptr
:
1773 enc_size
= DWARF2_ADDR_SIZE (stdoutput
);
1775 case DW_EH_PE_udata2
:
1778 case DW_EH_PE_udata4
:
1781 case DW_EH_PE_udata8
:
1788 /* If the user has requested absolute encoding,
1789 then use the smaller DW_OP_addr encoding. */
1790 if (insn
->u
.ea
.encoding
== DW_EH_PE_absptr
)
1792 out_uleb128 (1 + enc_size
);
1793 out_one (DW_OP_addr
);
1797 out_uleb128 (1 + 1 + enc_size
);
1798 out_one (DW_OP_GNU_encoded_addr
);
1801 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1803 #if CFI_DIFF_EXPR_OK
1804 insn
->u
.ea
.exp
.X_op
= O_subtract
;
1805 insn
->u
.ea
.exp
.X_op_symbol
= symbol_temp_new_now ();
1806 #elif defined (tc_cfi_emit_pcrel_expr)
1807 tc_cfi_emit_pcrel_expr (&insn
->u
.ea
.exp
, enc_size
);
1814 emit_expr (&insn
->u
.ea
.exp
, enc_size
);
1819 colon (insn
->u
.sym_name
);
1828 output_cie (struct cie_entry
*cie
, bfd_boolean eh_frame
, int align
)
1830 symbolS
*after_size_address
, *end_address
;
1832 struct cfi_insn_data
*i
;
1833 offsetT augmentation_size
;
1835 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1837 cie
->start_address
= symbol_temp_new_now ();
1838 after_size_address
= symbol_temp_make ();
1839 end_address
= symbol_temp_make ();
1841 exp
.X_op
= O_subtract
;
1842 exp
.X_add_symbol
= end_address
;
1843 exp
.X_op_symbol
= after_size_address
;
1844 exp
.X_add_number
= 0;
1846 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1847 emit_expr (&exp
, 4); /* Length. */
1850 if (fmt
== dwarf2_format_64bit
)
1852 emit_expr (&exp
, 8); /* Length. */
1854 symbol_set_value_now (after_size_address
);
1856 out_four (0); /* CIE id. */
1859 out_four (-1); /* CIE id. */
1860 if (fmt
!= dwarf2_format_32bit
)
1863 out_one (flag_dwarf_cie_version
); /* Version. */
1866 out_one ('z'); /* Augmentation. */
1867 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1869 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1872 #ifdef tc_output_cie_extra
1873 tc_output_cie_extra (cie
);
1876 if (cie
->signal_frame
)
1879 if (flag_dwarf_cie_version
>= 4)
1881 /* For now we are assuming a flat address space with 4 or 8 byte
1883 int address_size
= dwarf2_format_32bit
? 4 : 8;
1884 out_one (address_size
); /* Address size. */
1885 out_one (0); /* Segment size. */
1887 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH
); /* Code alignment. */
1888 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT
); /* Data alignment. */
1889 if (flag_dwarf_cie_version
== 1) /* Return column. */
1891 if ((cie
->return_column
& 0xff) != cie
->return_column
)
1892 as_bad (_("return column number %d overflows in CIE version 1"),
1893 cie
->return_column
);
1894 out_one (cie
->return_column
);
1897 out_uleb128 (cie
->return_column
);
1900 augmentation_size
= 1 + (cie
->lsda_encoding
!= DW_EH_PE_omit
);
1901 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1902 augmentation_size
+= 1 + encoding_size (cie
->per_encoding
);
1903 out_uleb128 (augmentation_size
); /* Augmentation size. */
1905 emit_expr_encoded (&cie
->personality
, cie
->per_encoding
, TRUE
);
1907 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1908 out_one (cie
->lsda_encoding
);
1911 switch (DWARF2_FDE_RELOC_SIZE
)
1914 enc
= DW_EH_PE_sdata2
;
1917 enc
= DW_EH_PE_sdata4
;
1920 enc
= DW_EH_PE_sdata8
;
1925 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1926 enc
|= DW_EH_PE_pcrel
;
1928 #ifdef DWARF2_FDE_RELOC_ENCODING
1929 /* Allow target to override encoding. */
1930 enc
= DWARF2_FDE_RELOC_ENCODING (enc
);
1932 cie
->fde_encoding
= enc
;
1938 for (i
= cie
->first
; i
!= cie
->last
; i
= i
->next
)
1940 if (CUR_SEG (i
) != CUR_SEG (cie
))
1942 output_cfi_insn (i
);
1946 frag_align (align
, DW_CFA_nop
, 0);
1947 symbol_set_value_now (end_address
);
1951 output_fde (struct fde_entry
*fde
, struct cie_entry
*cie
,
1952 bfd_boolean eh_frame
, struct cfi_insn_data
*first
,
1955 symbolS
*after_size_address
, *end_address
;
1957 offsetT augmentation_size
;
1958 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1959 unsigned int offset_size
;
1960 unsigned int addr_size
;
1962 after_size_address
= symbol_temp_make ();
1963 end_address
= symbol_temp_make ();
1965 exp
.X_op
= O_subtract
;
1966 exp
.X_add_symbol
= end_address
;
1967 exp
.X_op_symbol
= after_size_address
;
1968 exp
.X_add_number
= 0;
1969 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1973 if (fmt
== dwarf2_format_64bit
)
1977 emit_expr (&exp
, offset_size
); /* Length. */
1978 symbol_set_value_now (after_size_address
);
1982 exp
.X_op
= O_subtract
;
1983 exp
.X_add_symbol
= after_size_address
;
1984 exp
.X_op_symbol
= cie
->start_address
;
1985 exp
.X_add_number
= 0;
1986 emit_expr (&exp
, offset_size
); /* CIE offset. */
1990 TC_DWARF2_EMIT_OFFSET (cie
->start_address
, offset_size
);
1993 exp
.X_op
= O_symbol
;
1996 bfd_reloc_code_real_type code
1997 = tc_cfi_reloc_for_encoding (cie
->fde_encoding
);
1998 addr_size
= DWARF2_FDE_RELOC_SIZE
;
1999 if (code
!= BFD_RELOC_NONE
)
2001 reloc_howto_type
*howto
= bfd_reloc_type_lookup (stdoutput
, code
);
2002 char *p
= frag_more (addr_size
);
2003 gas_assert (addr_size
== (unsigned) howto
->bitsize
/ 8);
2004 md_number_to_chars (p
, 0, addr_size
);
2005 fix_new (frag_now
, p
- frag_now
->fr_literal
, addr_size
,
2006 fde
->start_address
, 0, howto
->pc_relative
, code
);
2010 exp
.X_op
= O_subtract
;
2011 exp
.X_add_number
= 0;
2012 #if CFI_DIFF_EXPR_OK
2013 exp
.X_add_symbol
= fde
->start_address
;
2014 exp
.X_op_symbol
= symbol_temp_new_now ();
2015 emit_expr (&exp
, addr_size
); /* Code offset. */
2017 exp
.X_op
= O_symbol
;
2018 exp
.X_add_symbol
= fde
->start_address
;
2020 #if defined(tc_cfi_emit_pcrel_expr)
2021 tc_cfi_emit_pcrel_expr (&exp
, addr_size
); /* Code offset. */
2023 emit_expr (&exp
, addr_size
); /* Code offset. */
2030 exp
.X_add_number
= 0;
2031 exp
.X_add_symbol
= fde
->start_address
;
2032 addr_size
= DWARF2_ADDR_SIZE (stdoutput
);
2033 emit_expr (&exp
, addr_size
);
2036 exp
.X_op
= O_subtract
;
2037 exp
.X_add_symbol
= fde
->end_address
;
2038 exp
.X_op_symbol
= fde
->start_address
; /* Code length. */
2039 exp
.X_add_number
= 0;
2040 emit_expr (&exp
, addr_size
);
2042 augmentation_size
= encoding_size (fde
->lsda_encoding
);
2044 out_uleb128 (augmentation_size
); /* Augmentation size. */
2046 emit_expr_encoded (&fde
->lsda
, cie
->lsda_encoding
, FALSE
);
2048 for (; first
; first
= first
->next
)
2049 if (CUR_SEG (first
) == CUR_SEG (fde
))
2050 output_cfi_insn (first
);
2052 frag_align (align
, DW_CFA_nop
, 0);
2053 symbol_set_value_now (end_address
);
2056 static struct cie_entry
*
2057 select_cie_for_fde (struct fde_entry
*fde
, bfd_boolean eh_frame
,
2058 struct cfi_insn_data
**pfirst
, int align
)
2060 struct cfi_insn_data
*i
, *j
;
2061 struct cie_entry
*cie
;
2063 for (cie
= cie_root
; cie
; cie
= cie
->next
)
2065 if (CUR_SEG (cie
) != CUR_SEG (fde
))
2067 #ifdef tc_cie_fde_equivalent_extra
2068 if (!tc_cie_fde_equivalent_extra (cie
, fde
))
2071 if (cie
->return_column
!= fde
->return_column
2072 || cie
->signal_frame
!= fde
->signal_frame
2073 || cie
->per_encoding
!= fde
->per_encoding
2074 || cie
->lsda_encoding
!= fde
->lsda_encoding
)
2076 if (cie
->per_encoding
!= DW_EH_PE_omit
)
2078 if (cie
->personality
.X_op
!= fde
->personality
.X_op
2079 || (cie
->personality
.X_add_number
2080 != fde
->personality
.X_add_number
))
2082 switch (cie
->personality
.X_op
)
2085 if (cie
->personality
.X_unsigned
!= fde
->personality
.X_unsigned
)
2089 if (cie
->personality
.X_add_symbol
2090 != fde
->personality
.X_add_symbol
)
2097 for (i
= cie
->first
, j
= fde
->data
;
2098 i
!= cie
->last
&& j
!= NULL
;
2099 i
= i
->next
, j
= j
->next
)
2101 if (i
->insn
!= j
->insn
)
2105 case DW_CFA_advance_loc
:
2106 case DW_CFA_remember_state
:
2107 /* We reached the first advance/remember in the FDE,
2108 but did not reach the end of the CIE list. */
2112 case DW_CFA_def_cfa
:
2113 if (i
->u
.ri
.reg
!= j
->u
.ri
.reg
)
2115 if (i
->u
.ri
.offset
!= j
->u
.ri
.offset
)
2119 case DW_CFA_register
:
2120 if (i
->u
.rr
.reg1
!= j
->u
.rr
.reg1
)
2122 if (i
->u
.rr
.reg2
!= j
->u
.rr
.reg2
)
2126 case DW_CFA_def_cfa_register
:
2127 case DW_CFA_restore
:
2128 case DW_CFA_undefined
:
2129 case DW_CFA_same_value
:
2130 if (i
->u
.r
!= j
->u
.r
)
2134 case DW_CFA_def_cfa_offset
:
2135 if (i
->u
.i
!= j
->u
.i
)
2140 case CFI_val_encoded_addr
:
2142 /* Don't bother matching these for now. */
2150 /* Success if we reached the end of the CIE list, and we've either
2151 run out of FDE entries or we've encountered an advance,
2152 remember, or escape. */
2155 || j
->insn
== DW_CFA_advance_loc
2156 || j
->insn
== DW_CFA_remember_state
2157 || j
->insn
== CFI_escape
2158 || j
->insn
== CFI_val_encoded_addr
2159 || j
->insn
== CFI_label
))
2168 cie
= XNEW (struct cie_entry
);
2169 cie
->next
= cie_root
;
2171 SET_CUR_SEG (cie
, CUR_SEG (fde
));
2172 cie
->return_column
= fde
->return_column
;
2173 cie
->signal_frame
= fde
->signal_frame
;
2174 cie
->per_encoding
= fde
->per_encoding
;
2175 cie
->lsda_encoding
= fde
->lsda_encoding
;
2176 cie
->personality
= fde
->personality
;
2177 cie
->first
= fde
->data
;
2178 #ifdef tc_cie_entry_init_extra
2179 tc_cie_entry_init_extra (cie
, fde
)
2182 for (i
= cie
->first
; i
; i
= i
->next
)
2183 if (i
->insn
== DW_CFA_advance_loc
2184 || i
->insn
== DW_CFA_remember_state
2185 || i
->insn
== CFI_escape
2186 || i
->insn
== CFI_val_encoded_addr
2187 || i
->insn
== CFI_label
)
2193 output_cie (cie
, eh_frame
, align
);
2198 #ifdef md_reg_eh_frame_to_debug_frame
2200 cfi_change_reg_numbers (struct cfi_insn_data
*insn
, segT ccseg
)
2202 for (; insn
; insn
= insn
->next
)
2204 if (CUR_SEG (insn
) != ccseg
)
2208 case DW_CFA_advance_loc
:
2209 case DW_CFA_def_cfa_offset
:
2210 case DW_CFA_remember_state
:
2211 case DW_CFA_restore_state
:
2212 case DW_CFA_GNU_window_save
:
2217 case DW_CFA_def_cfa
:
2219 insn
->u
.ri
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ri
.reg
);
2222 case DW_CFA_def_cfa_register
:
2223 case DW_CFA_undefined
:
2224 case DW_CFA_same_value
:
2225 case DW_CFA_restore
:
2226 insn
->u
.r
= md_reg_eh_frame_to_debug_frame (insn
->u
.r
);
2229 case DW_CFA_register
:
2230 insn
->u
.rr
.reg1
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg1
);
2231 insn
->u
.rr
.reg2
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg2
);
2234 case CFI_val_encoded_addr
:
2235 insn
->u
.ea
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ea
.reg
);
2244 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
2247 #if SUPPORT_COMPACT_EH
2249 cfi_emit_eh_header (symbolS
*sym
, bfd_vma addend
)
2253 exp
.X_add_number
= addend
;
2254 exp
.X_add_symbol
= sym
;
2255 emit_expr_encoded (&exp
, DW_EH_PE_sdata4
| DW_EH_PE_pcrel
, FALSE
);
2259 output_eh_header (struct fde_entry
*fde
)
2264 if (fde
->eh_header_type
== EH_COMPACT_INLINE
)
2269 cfi_emit_eh_header (fde
->start_address
, addend
);
2271 if (fde
->eh_header_type
== EH_COMPACT_INLINE
)
2274 /* Inline entries always use PR1. */
2276 memcpy(p
, fde
->eh_data
, 3);
2280 if (fde
->eh_header_type
== EH_COMPACT_LEGACY
)
2282 else if (fde
->eh_header_type
== EH_COMPACT_OUTLINE
2283 || fde
->eh_header_type
== EH_COMPACT_OUTLINE_DONE
)
2287 cfi_emit_eh_header (fde
->eh_loc
, addend
);
2295 struct cie_entry
*cie
, *cie_next
;
2296 segT cfi_seg
, ccseg
;
2297 struct fde_entry
*fde
;
2298 struct cfi_insn_data
*first
;
2299 int save_flag_traditional_format
, seek_next_seg
;
2301 if (all_fde_data
== 0)
2304 cfi_sections_set
= TRUE
;
2305 if ((all_cfi_sections
& CFI_EMIT_eh_frame
) != 0
2306 || (all_cfi_sections
& CFI_EMIT_eh_frame_compact
) != 0)
2308 /* Make sure check_eh_frame doesn't do anything with our output. */
2309 save_flag_traditional_format
= flag_traditional_format
;
2310 flag_traditional_format
= 1;
2312 if (!EH_FRAME_LINKONCE
)
2314 /* Open .eh_frame section. */
2315 cfi_seg
= get_cfi_seg (NULL
, ".eh_frame",
2316 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2317 | DWARF2_EH_FRAME_READ_ONLY
),
2318 EH_FRAME_ALIGNMENT
);
2319 #ifdef md_fix_up_eh_frame
2320 md_fix_up_eh_frame (cfi_seg
);
2331 for (cie
= cie_root
; cie
; cie
= cie_next
)
2333 cie_next
= cie
->next
;
2334 free ((void *) cie
);
2338 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2340 if ((fde
->sections
& CFI_EMIT_eh_frame
) == 0
2341 && (fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
2344 #if SUPPORT_COMPACT_EH
2345 /* Emit a LEGACY format header if we have processed all
2346 of the .cfi directives without encountering either inline or
2347 out-of-line compact unwinding opcodes. */
2348 if (fde
->eh_header_type
== EH_COMPACT_HAS_LSDA
2349 || fde
->eh_header_type
== EH_COMPACT_UNKNOWN
)
2350 fde
->eh_header_type
= EH_COMPACT_LEGACY
;
2352 if (fde
->eh_header_type
!= EH_COMPACT_LEGACY
)
2355 if (EH_FRAME_LINKONCE
)
2359 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2366 ccseg
= CUR_SEG (fde
);
2367 /* Open .eh_frame section. */
2368 cfi_seg
= get_cfi_seg (ccseg
, ".eh_frame",
2369 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2370 | DWARF2_EH_FRAME_READ_ONLY
),
2371 EH_FRAME_ALIGNMENT
);
2372 #ifdef md_fix_up_eh_frame
2373 md_fix_up_eh_frame (cfi_seg
);
2379 SET_HANDLED (fde
, 1);
2382 if (fde
->end_address
== NULL
)
2384 as_bad (_("open CFI at the end of file; "
2385 "missing .cfi_endproc directive"));
2386 fde
->end_address
= fde
->start_address
;
2389 cie
= select_cie_for_fde (fde
, TRUE
, &first
, 2);
2390 fde
->eh_loc
= symbol_temp_new_now ();
2391 output_fde (fde
, cie
, TRUE
, first
,
2392 fde
->next
== NULL
? EH_FRAME_ALIGNMENT
: 2);
2395 while (EH_FRAME_LINKONCE
&& seek_next_seg
== 2);
2397 if (EH_FRAME_LINKONCE
)
2398 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2399 SET_HANDLED (fde
, 0);
2401 #if SUPPORT_COMPACT_EH
2404 /* Create remaining out of line table entries. */
2410 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2412 if ((fde
->sections
& CFI_EMIT_eh_frame
) == 0
2413 && (fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
2416 if (fde
->eh_header_type
!= EH_COMPACT_OUTLINE
)
2420 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2427 ccseg
= CUR_SEG (fde
);
2428 /* Open .gnu_extab section. */
2429 get_cfi_seg (ccseg
, ".gnu_extab",
2430 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2431 | DWARF2_EH_FRAME_READ_ONLY
),
2435 SET_HANDLED (fde
, 1);
2437 frag_align (1, 0, 0);
2438 record_alignment (now_seg
, 1);
2439 output_compact_unwind_data (fde
, 1);
2442 while (EH_FRAME_LINKONCE
&& seek_next_seg
== 2);
2444 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2445 SET_HANDLED (fde
, 0);
2447 /* Create index table fragments. */
2453 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2455 if ((fde
->sections
& CFI_EMIT_eh_frame
) == 0
2456 && (fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
2461 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2468 ccseg
= CUR_SEG (fde
);
2469 /* Open .eh_frame_entry section. */
2470 cfi_seg
= get_cfi_seg (ccseg
, ".eh_frame_entry",
2471 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2472 | DWARF2_EH_FRAME_READ_ONLY
),
2476 SET_HANDLED (fde
, 1);
2478 output_eh_header (fde
);
2481 while (seek_next_seg
== 2);
2483 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2484 SET_HANDLED (fde
, 0);
2486 #endif /* SUPPORT_COMPACT_EH */
2488 flag_traditional_format
= save_flag_traditional_format
;
2491 cfi_sections_set
= TRUE
;
2492 if ((all_cfi_sections
& CFI_EMIT_debug_frame
) != 0)
2494 int alignment
= ffs (DWARF2_ADDR_SIZE (stdoutput
)) - 1;
2496 if (!SUPPORT_FRAME_LINKONCE
)
2497 get_cfi_seg (NULL
, ".debug_frame",
2498 SEC_READONLY
| SEC_DEBUGGING
,
2506 for (cie
= cie_root
; cie
; cie
= cie_next
)
2508 cie_next
= cie
->next
;
2509 free ((void *) cie
);
2513 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2515 if ((fde
->sections
& CFI_EMIT_debug_frame
) == 0)
2518 if (SUPPORT_FRAME_LINKONCE
)
2522 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2529 ccseg
= CUR_SEG (fde
);
2530 /* Open .debug_frame section. */
2531 get_cfi_seg (ccseg
, ".debug_frame",
2532 SEC_READONLY
| SEC_DEBUGGING
,
2536 SET_HANDLED (fde
, 1);
2538 if (fde
->end_address
== NULL
)
2540 as_bad (_("open CFI at the end of file; "
2541 "missing .cfi_endproc directive"));
2542 fde
->end_address
= fde
->start_address
;
2545 fde
->per_encoding
= DW_EH_PE_omit
;
2546 fde
->lsda_encoding
= DW_EH_PE_omit
;
2547 cfi_change_reg_numbers (fde
->data
, ccseg
);
2548 cie
= select_cie_for_fde (fde
, FALSE
, &first
, alignment
);
2549 output_fde (fde
, cie
, FALSE
, first
, alignment
);
2552 while (SUPPORT_FRAME_LINKONCE
&& seek_next_seg
== 2);
2554 if (SUPPORT_FRAME_LINKONCE
)
2555 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2556 SET_HANDLED (fde
, 0);
2560 #else /* TARGET_USE_CFIPOP */
2562 /* Emit an intelligible error message for missing support. */
2565 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED
)
2567 as_bad (_("CFI is not supported for this target"));
2568 ignore_rest_of_line ();
2571 const pseudo_typeS cfi_pseudo_table
[] =
2573 { "cfi_sections", dot_cfi_dummy
, 0 },
2574 { "cfi_startproc", dot_cfi_dummy
, 0 },
2575 { "cfi_endproc", dot_cfi_dummy
, 0 },
2576 { "cfi_fde_data", dot_cfi_dummy
, 0 },
2577 { "cfi_def_cfa", dot_cfi_dummy
, 0 },
2578 { "cfi_def_cfa_register", dot_cfi_dummy
, 0 },
2579 { "cfi_def_cfa_offset", dot_cfi_dummy
, 0 },
2580 { "cfi_adjust_cfa_offset", dot_cfi_dummy
, 0 },
2581 { "cfi_offset", dot_cfi_dummy
, 0 },
2582 { "cfi_rel_offset", dot_cfi_dummy
, 0 },
2583 { "cfi_register", dot_cfi_dummy
, 0 },
2584 { "cfi_return_column", dot_cfi_dummy
, 0 },
2585 { "cfi_restore", dot_cfi_dummy
, 0 },
2586 { "cfi_undefined", dot_cfi_dummy
, 0 },
2587 { "cfi_same_value", dot_cfi_dummy
, 0 },
2588 { "cfi_remember_state", dot_cfi_dummy
, 0 },
2589 { "cfi_restore_state", dot_cfi_dummy
, 0 },
2590 { "cfi_window_save", dot_cfi_dummy
, 0 },
2591 { "cfi_escape", dot_cfi_dummy
, 0 },
2592 { "cfi_signal_frame", dot_cfi_dummy
, 0 },
2593 { "cfi_personality", dot_cfi_dummy
, 0 },
2594 { "cfi_personality_id", dot_cfi_dummy
, 0 },
2595 { "cfi_lsda", dot_cfi_dummy
, 0 },
2596 { "cfi_val_encoded_addr", dot_cfi_dummy
, 0 },
2597 { "cfi_label", dot_cfi_dummy
, 0 },
2598 { "cfi_inline_lsda", dot_cfi_dummy
, 0 },
2599 { "cfi_val_offset", dot_cfi_dummy
, 0 },
2607 #endif /* TARGET_USE_CFIPOP */