1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright (C) 2003-2022 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 bool compact_eh
;
118 static htab_t 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
, bool 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 || (name
= bfd_section_name (seg
)) == NULL
235 return notes_strdup (base_name
);
237 dollar
= strchr (name
, '$');
238 dot
= strchr (name
+ 1, '.');
242 if (!strcmp (base_name
, ".eh_frame_entry")
243 && strcmp (name
, ".text") != 0)
244 return notes_concat (base_name
, ".", name
, NULL
);
252 else if (dot
< dollar
)
257 return notes_concat (base_name
, name
, NULL
);
260 /* Allocate a dwcfi_seg_list structure. */
262 static struct dwcfi_seg_list
*
263 alloc_debugseg_item (segT seg
, int subseg
, char *name
)
265 struct dwcfi_seg_list
*r
;
267 r
= notes_alloc (sizeof (*r
) + strlen (name
));
275 is_now_linkonce_segment (void)
280 if ((bfd_section_flags (now_seg
)
281 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
282 | SEC_LINK_DUPLICATES_ONE_ONLY
| SEC_LINK_DUPLICATES_SAME_SIZE
283 | SEC_LINK_DUPLICATES_SAME_CONTENTS
)) != 0)
288 /* Generate debug... segment with same linkonce properties
292 make_debug_seg (segT cseg
, char *name
, int sflags
)
294 segT save_seg
= now_seg
;
295 int save_subseg
= now_subseg
;
299 r
= subseg_new (name
, 0);
301 /* Check if code segment is marked as linked once. */
305 flags
= (bfd_section_flags (cseg
)
306 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
307 | SEC_LINK_DUPLICATES_ONE_ONLY
| SEC_LINK_DUPLICATES_SAME_SIZE
308 | SEC_LINK_DUPLICATES_SAME_CONTENTS
));
310 /* Add standard section flags. */
313 /* Apply possibly linked once flags to new generated segment, too. */
314 if (!bfd_set_section_flags (r
, flags
))
315 as_bad (_("bfd_set_section_flags: %s"),
316 bfd_errmsg (bfd_get_error ()));
318 /* Restore to previous segment. */
319 if (save_seg
!= NULL
)
320 subseg_set (save_seg
, save_subseg
);
324 static struct dwcfi_seg_list
*
325 dwcfi_hash_find (char *name
)
327 return (struct dwcfi_seg_list
*) str_hash_find (dwcfi_hash
, name
);
330 static struct dwcfi_seg_list
*
331 dwcfi_hash_find_or_make (segT cseg
, const char *base_name
, int flags
)
333 struct dwcfi_seg_list
*item
;
336 /* Initialize dwcfi_hash once. */
338 dwcfi_hash
= str_htab_create ();
340 name
= get_debugseg_name (cseg
, base_name
);
342 item
= dwcfi_hash_find (name
);
345 item
= alloc_debugseg_item (make_debug_seg (cseg
, name
, flags
), 0, name
);
347 str_hash_insert (dwcfi_hash
, item
->seg_name
, item
, 0);
355 /* ??? Share this with dwarf2cfg.c. */
356 #ifndef TC_DWARF2_EMIT_OFFSET
357 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
359 /* Create an offset to .dwarf2_*. */
362 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
367 exp
.X_add_symbol
= symbol
;
368 exp
.X_add_number
= 0;
369 emit_expr (&exp
, size
);
373 struct cfi_escape_data
375 struct cfi_escape_data
*next
;
381 struct cie_entry
*next
;
382 #if MULTIPLE_FRAME_SECTIONS
385 symbolS
*start_address
;
386 unsigned int return_column
;
387 unsigned int signal_frame
;
388 unsigned char fde_encoding
;
389 unsigned char per_encoding
;
390 unsigned char lsda_encoding
;
391 expressionS personality
;
392 #ifdef tc_cie_entry_extras
395 struct cfi_insn_data
*first
, *last
;
398 /* List of FDE entries. */
400 struct fde_entry
*all_fde_data
;
401 static struct fde_entry
**last_fde_data
= &all_fde_data
;
403 /* List of CIEs so that they could be reused. */
404 static struct cie_entry
*cie_root
;
406 /* Construct a new FDE structure and add it to the end of the fde list. */
408 static struct fde_entry
*
409 alloc_fde_entry (void)
411 struct fde_entry
*fde
= XCNEW (struct fde_entry
);
413 frchain_now
->frch_cfi_data
= XCNEW (struct frch_cfi_data
);
414 frchain_now
->frch_cfi_data
->cur_fde_data
= fde
;
415 *last_fde_data
= fde
;
416 last_fde_data
= &fde
->next
;
417 SET_CUR_SEG (fde
, is_now_linkonce_segment ());
418 SET_HANDLED (fde
, 0);
419 fde
->last
= &fde
->data
;
420 fde
->return_column
= DWARF2_DEFAULT_RETURN_COLUMN
;
421 fde
->per_encoding
= DW_EH_PE_omit
;
422 fde
->lsda_encoding
= DW_EH_PE_omit
;
423 fde
->eh_header_type
= EH_COMPACT_UNKNOWN
;
424 #ifdef tc_fde_entry_init_extra
425 tc_fde_entry_init_extra (fde
)
431 /* The following functions are available for a backend to construct its
432 own unwind information, usually from legacy unwind directives. */
434 /* Construct a new INSN structure and add it to the end of the insn list
435 for the currently active FDE. */
437 static bool cfi_sections_set
= false;
438 static int cfi_sections
= CFI_EMIT_eh_frame
;
439 int all_cfi_sections
= 0;
440 static struct fde_entry
*last_fde
;
442 static struct cfi_insn_data
*
443 alloc_cfi_insn_data (void)
445 struct cfi_insn_data
*insn
= XCNEW (struct cfi_insn_data
);
446 struct fde_entry
*cur_fde_data
= frchain_now
->frch_cfi_data
->cur_fde_data
;
448 *cur_fde_data
->last
= insn
;
449 cur_fde_data
->last
= &insn
->next
;
450 SET_CUR_SEG (insn
, is_now_linkonce_segment ());
454 /* Construct a new FDE structure that begins at LABEL. */
457 cfi_new_fde (symbolS
*label
)
459 struct fde_entry
*fde
= alloc_fde_entry ();
460 fde
->start_address
= label
;
461 frchain_now
->frch_cfi_data
->last_address
= label
;
464 /* End the currently open FDE. */
467 cfi_end_fde (symbolS
*label
)
469 frchain_now
->frch_cfi_data
->cur_fde_data
->end_address
= label
;
470 free (frchain_now
->frch_cfi_data
);
471 frchain_now
->frch_cfi_data
= NULL
;
474 /* Set the return column for the current FDE. */
477 cfi_set_return_column (unsigned regno
)
479 frchain_now
->frch_cfi_data
->cur_fde_data
->return_column
= regno
;
483 cfi_set_sections (void)
485 frchain_now
->frch_cfi_data
->cur_fde_data
->sections
= all_cfi_sections
;
486 cfi_sections_set
= true;
489 /* Universal functions to store new instructions. */
492 cfi_add_CFA_insn (int insn
)
494 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
496 insn_ptr
->insn
= insn
;
500 cfi_add_CFA_insn_reg (int insn
, unsigned regno
)
502 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
504 insn_ptr
->insn
= insn
;
505 insn_ptr
->u
.r
= regno
;
509 cfi_add_CFA_insn_offset (int insn
, offsetT offset
)
511 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
513 insn_ptr
->insn
= insn
;
514 insn_ptr
->u
.i
= offset
;
518 cfi_add_CFA_insn_reg_reg (int insn
, unsigned reg1
, unsigned reg2
)
520 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
522 insn_ptr
->insn
= insn
;
523 insn_ptr
->u
.rr
.reg1
= reg1
;
524 insn_ptr
->u
.rr
.reg2
= reg2
;
528 cfi_add_CFA_insn_reg_offset (int insn
, unsigned regno
, offsetT offset
)
530 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
532 insn_ptr
->insn
= insn
;
533 insn_ptr
->u
.ri
.reg
= regno
;
534 insn_ptr
->u
.ri
.offset
= offset
;
537 /* Add a CFI insn to advance the PC from the last address to LABEL. */
540 cfi_add_advance_loc (symbolS
*label
)
542 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
544 insn
->insn
= DW_CFA_advance_loc
;
545 insn
->u
.ll
.lab1
= frchain_now
->frch_cfi_data
->last_address
;
546 insn
->u
.ll
.lab2
= label
;
548 frchain_now
->frch_cfi_data
->last_address
= label
;
551 /* Add a CFI insn to label the current position in the CFI segment. */
554 cfi_add_label (const char *name
)
556 unsigned int len
= strlen (name
) + 1;
557 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
559 insn
->insn
= CFI_label
;
560 obstack_grow (¬es
, name
, len
);
561 insn
->u
.sym_name
= (char *) obstack_finish (¬es
);
564 /* Add a DW_CFA_offset record to the CFI data. */
567 cfi_add_CFA_offset (unsigned regno
, offsetT offset
)
569 unsigned int abs_data_align
;
571 gas_assert (DWARF2_CIE_DATA_ALIGNMENT
!= 0);
572 cfi_add_CFA_insn_reg_offset (DW_CFA_offset
, regno
, offset
);
574 abs_data_align
= (DWARF2_CIE_DATA_ALIGNMENT
< 0
575 ? -DWARF2_CIE_DATA_ALIGNMENT
: DWARF2_CIE_DATA_ALIGNMENT
);
576 if (offset
% abs_data_align
)
577 as_bad (_("register save offset not a multiple of %u"), abs_data_align
);
580 /* Add a DW_CFA_val_offset record to the CFI data. */
583 cfi_add_CFA_val_offset (unsigned regno
, offsetT offset
)
585 unsigned int abs_data_align
;
587 gas_assert (DWARF2_CIE_DATA_ALIGNMENT
!= 0);
588 cfi_add_CFA_insn_reg_offset (DW_CFA_val_offset
, regno
, offset
);
590 abs_data_align
= (DWARF2_CIE_DATA_ALIGNMENT
< 0
591 ? -DWARF2_CIE_DATA_ALIGNMENT
: DWARF2_CIE_DATA_ALIGNMENT
);
592 if (offset
% abs_data_align
)
593 as_bad (_("register save offset not a multiple of %u"), abs_data_align
);
596 /* Add a DW_CFA_def_cfa record to the CFI data. */
599 cfi_add_CFA_def_cfa (unsigned regno
, offsetT offset
)
601 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa
, regno
, offset
);
602 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
605 /* Add a DW_CFA_register record to the CFI data. */
608 cfi_add_CFA_register (unsigned reg1
, unsigned reg2
)
610 cfi_add_CFA_insn_reg_reg (DW_CFA_register
, reg1
, reg2
);
613 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
616 cfi_add_CFA_def_cfa_register (unsigned regno
)
618 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register
, regno
);
621 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
624 cfi_add_CFA_def_cfa_offset (offsetT offset
)
626 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset
, offset
);
627 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
631 cfi_add_CFA_restore (unsigned regno
)
633 cfi_add_CFA_insn_reg (DW_CFA_restore
, regno
);
637 cfi_add_CFA_undefined (unsigned regno
)
639 cfi_add_CFA_insn_reg (DW_CFA_undefined
, regno
);
643 cfi_add_CFA_same_value (unsigned regno
)
645 cfi_add_CFA_insn_reg (DW_CFA_same_value
, regno
);
649 cfi_add_CFA_remember_state (void)
651 struct cfa_save_data
*p
;
653 cfi_add_CFA_insn (DW_CFA_remember_state
);
655 p
= XNEW (struct cfa_save_data
);
656 p
->cfa_offset
= frchain_now
->frch_cfi_data
->cur_cfa_offset
;
657 p
->next
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
658 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
;
662 cfi_add_CFA_restore_state (void)
664 struct cfa_save_data
*p
;
666 cfi_add_CFA_insn (DW_CFA_restore_state
);
668 p
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
671 frchain_now
->frch_cfi_data
->cur_cfa_offset
= p
->cfa_offset
;
672 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
->next
;
676 as_bad (_("CFI state restore without previous remember"));
680 /* Parse CFI assembler directives. */
682 static void dot_cfi (int);
683 static void dot_cfi_escape (int);
684 static void dot_cfi_sections (int);
685 static void dot_cfi_startproc (int);
686 static void dot_cfi_endproc (int);
687 static void dot_cfi_fde_data (int);
688 static void dot_cfi_personality (int);
689 static void dot_cfi_personality_id (int);
690 static void dot_cfi_lsda (int);
691 static void dot_cfi_val_encoded_addr (int);
692 static void dot_cfi_inline_lsda (int);
693 static void dot_cfi_label (int);
695 const pseudo_typeS cfi_pseudo_table
[] =
697 { "cfi_sections", dot_cfi_sections
, 0 },
698 { "cfi_startproc", dot_cfi_startproc
, 0 },
699 { "cfi_endproc", dot_cfi_endproc
, 0 },
700 { "cfi_fde_data", dot_cfi_fde_data
, 0 },
701 { "cfi_def_cfa", dot_cfi
, DW_CFA_def_cfa
},
702 { "cfi_def_cfa_register", dot_cfi
, DW_CFA_def_cfa_register
},
703 { "cfi_def_cfa_offset", dot_cfi
, DW_CFA_def_cfa_offset
},
704 { "cfi_adjust_cfa_offset", dot_cfi
, CFI_adjust_cfa_offset
},
705 { "cfi_offset", dot_cfi
, DW_CFA_offset
},
706 { "cfi_rel_offset", dot_cfi
, CFI_rel_offset
},
707 { "cfi_register", dot_cfi
, DW_CFA_register
},
708 { "cfi_return_column", dot_cfi
, CFI_return_column
},
709 { "cfi_restore", dot_cfi
, DW_CFA_restore
},
710 { "cfi_undefined", dot_cfi
, DW_CFA_undefined
},
711 { "cfi_same_value", dot_cfi
, DW_CFA_same_value
},
712 { "cfi_remember_state", dot_cfi
, DW_CFA_remember_state
},
713 { "cfi_restore_state", dot_cfi
, DW_CFA_restore_state
},
714 { "cfi_window_save", dot_cfi
, DW_CFA_GNU_window_save
},
715 { "cfi_negate_ra_state", dot_cfi
, DW_CFA_AARCH64_negate_ra_state
},
716 { "cfi_escape", dot_cfi_escape
, 0 },
717 { "cfi_signal_frame", dot_cfi
, CFI_signal_frame
},
718 { "cfi_personality", dot_cfi_personality
, 0 },
719 { "cfi_personality_id", dot_cfi_personality_id
, 0 },
720 { "cfi_lsda", dot_cfi_lsda
, 0 },
721 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr
, 0 },
722 { "cfi_inline_lsda", dot_cfi_inline_lsda
, 0 },
723 { "cfi_label", dot_cfi_label
, 0 },
724 { "cfi_val_offset", dot_cfi
, DW_CFA_val_offset
},
729 cfi_parse_separator (void)
732 if (*input_line_pointer
== ',')
733 input_line_pointer
++;
735 as_bad (_("missing separator"));
738 #ifndef tc_parse_to_dw2regnum
740 tc_parse_to_dw2regnum (expressionS
*exp
)
742 # ifdef tc_regname_to_dw2regnum
744 if (is_name_beginner (*input_line_pointer
)
745 || (*input_line_pointer
== '%'
746 && is_name_beginner (*++input_line_pointer
)))
750 c
= get_symbol_name (& name
);
752 exp
->X_op
= O_constant
;
753 exp
->X_add_number
= tc_regname_to_dw2regnum (name
);
755 restore_line_pointer (c
);
759 expression_and_evaluate (exp
);
769 tc_parse_to_dw2regnum (&exp
);
774 regno
= exp
.X_add_number
;
784 as_bad (_("bad register expression"));
792 cfi_parse_const (void)
794 return get_absolute_expression ();
803 if (frchain_now
->frch_cfi_data
== NULL
)
805 as_bad (_("CFI instruction used without previous .cfi_startproc"));
806 ignore_rest_of_line ();
810 /* If the last address was not at the current PC, advance to current. */
811 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
812 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
814 cfi_add_advance_loc (symbol_temp_new_now ());
819 reg1
= cfi_parse_reg ();
820 cfi_parse_separator ();
821 offset
= cfi_parse_const ();
822 cfi_add_CFA_offset (reg1
, offset
);
825 case DW_CFA_val_offset
:
826 reg1
= cfi_parse_reg ();
827 cfi_parse_separator ();
828 offset
= cfi_parse_const ();
829 cfi_add_CFA_val_offset (reg1
, offset
);
833 reg1
= cfi_parse_reg ();
834 cfi_parse_separator ();
835 offset
= cfi_parse_const ();
836 cfi_add_CFA_offset (reg1
,
837 offset
- frchain_now
->frch_cfi_data
->cur_cfa_offset
);
841 reg1
= cfi_parse_reg ();
842 cfi_parse_separator ();
843 offset
= cfi_parse_const ();
844 cfi_add_CFA_def_cfa (reg1
, offset
);
847 case DW_CFA_register
:
848 reg1
= cfi_parse_reg ();
849 cfi_parse_separator ();
850 reg2
= cfi_parse_reg ();
851 cfi_add_CFA_register (reg1
, reg2
);
854 case DW_CFA_def_cfa_register
:
855 reg1
= cfi_parse_reg ();
856 cfi_add_CFA_def_cfa_register (reg1
);
859 case DW_CFA_def_cfa_offset
:
860 offset
= cfi_parse_const ();
861 cfi_add_CFA_def_cfa_offset (offset
);
864 case CFI_adjust_cfa_offset
:
865 offset
= cfi_parse_const ();
866 cfi_add_CFA_def_cfa_offset (frchain_now
->frch_cfi_data
->cur_cfa_offset
873 reg1
= cfi_parse_reg ();
874 cfi_add_CFA_restore (reg1
);
876 if (*input_line_pointer
!= ',')
878 ++input_line_pointer
;
882 case DW_CFA_undefined
:
885 reg1
= cfi_parse_reg ();
886 cfi_add_CFA_undefined (reg1
);
888 if (*input_line_pointer
!= ',')
890 ++input_line_pointer
;
894 case DW_CFA_same_value
:
895 reg1
= cfi_parse_reg ();
896 cfi_add_CFA_same_value (reg1
);
899 case CFI_return_column
:
900 reg1
= cfi_parse_reg ();
901 cfi_set_return_column (reg1
);
904 case DW_CFA_remember_state
:
905 cfi_add_CFA_remember_state ();
908 case DW_CFA_restore_state
:
909 cfi_add_CFA_restore_state ();
912 case DW_CFA_GNU_window_save
:
913 cfi_add_CFA_insn (DW_CFA_GNU_window_save
);
916 case CFI_signal_frame
:
917 frchain_now
->frch_cfi_data
->cur_fde_data
->signal_frame
= 1;
924 demand_empty_rest_of_line ();
928 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED
)
930 struct cfi_escape_data
*head
, **tail
, *e
;
931 struct cfi_insn_data
*insn
;
933 if (frchain_now
->frch_cfi_data
== NULL
)
935 as_bad (_("CFI instruction used without previous .cfi_startproc"));
936 ignore_rest_of_line ();
940 /* If the last address was not at the current PC, advance to current. */
941 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
942 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
944 cfi_add_advance_loc (symbol_temp_new_now ());
949 e
= XNEW (struct cfi_escape_data
);
950 do_parse_cons_expression (&e
->exp
, 1);
954 while (*input_line_pointer
++ == ',');
957 insn
= alloc_cfi_insn_data ();
958 insn
->insn
= CFI_escape
;
961 --input_line_pointer
;
962 demand_empty_rest_of_line ();
966 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED
)
968 struct fde_entry
*fde
;
971 if (frchain_now
->frch_cfi_data
== NULL
)
973 as_bad (_("CFI instruction used without previous .cfi_startproc"));
974 ignore_rest_of_line ();
978 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
979 encoding
= cfi_parse_const ();
980 if (encoding
== DW_EH_PE_omit
)
982 demand_empty_rest_of_line ();
983 fde
->per_encoding
= encoding
;
987 if ((encoding
& 0xff) != encoding
988 || ((((encoding
& 0x70) != 0
989 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
990 && (encoding
& 0x70) != DW_EH_PE_pcrel
993 /* leb128 can be handled, but does something actually need it? */
994 || (encoding
& 7) == DW_EH_PE_uleb128
995 || (encoding
& 7) > DW_EH_PE_udata8
)
996 && tc_cfi_reloc_for_encoding (encoding
) == BFD_RELOC_NONE
))
998 as_bad (_("invalid or unsupported encoding in .cfi_personality"));
999 ignore_rest_of_line ();
1003 if (*input_line_pointer
++ != ',')
1005 as_bad (_(".cfi_personality requires encoding and symbol arguments"));
1006 ignore_rest_of_line ();
1010 expression_and_evaluate (&fde
->personality
);
1011 switch (fde
->personality
.X_op
)
1016 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1017 encoding
= DW_EH_PE_omit
;
1020 encoding
= DW_EH_PE_omit
;
1024 fde
->per_encoding
= encoding
;
1026 if (encoding
== DW_EH_PE_omit
)
1028 as_bad (_("wrong second argument to .cfi_personality"));
1029 ignore_rest_of_line ();
1033 demand_empty_rest_of_line ();
1037 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED
)
1039 struct fde_entry
*fde
;
1042 if (frchain_now
->frch_cfi_data
== NULL
)
1044 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1045 ignore_rest_of_line ();
1049 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1050 encoding
= cfi_parse_const ();
1051 if (encoding
== DW_EH_PE_omit
)
1053 demand_empty_rest_of_line ();
1054 fde
->lsda_encoding
= encoding
;
1058 if ((encoding
& 0xff) != encoding
1059 || ((((encoding
& 0x70) != 0
1060 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
1061 && (encoding
& 0x70) != DW_EH_PE_pcrel
1064 /* leb128 can be handled, but does something actually need it? */
1065 || (encoding
& 7) == DW_EH_PE_uleb128
1066 || (encoding
& 7) > DW_EH_PE_udata8
)
1067 && tc_cfi_reloc_for_encoding (encoding
) == BFD_RELOC_NONE
))
1069 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1070 ignore_rest_of_line ();
1074 if (*input_line_pointer
++ != ',')
1076 as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
1077 ignore_rest_of_line ();
1081 fde
->lsda_encoding
= encoding
;
1083 expression_and_evaluate (&fde
->lsda
);
1084 switch (fde
->lsda
.X_op
)
1089 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1090 encoding
= DW_EH_PE_omit
;
1093 encoding
= DW_EH_PE_omit
;
1097 fde
->lsda_encoding
= encoding
;
1099 if (encoding
== DW_EH_PE_omit
)
1101 as_bad (_("wrong second argument to .cfi_lsda"));
1102 ignore_rest_of_line ();
1106 demand_empty_rest_of_line ();
1110 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED
)
1112 struct cfi_insn_data
*insn_ptr
;
1115 if (frchain_now
->frch_cfi_data
== NULL
)
1117 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1118 ignore_rest_of_line ();
1122 /* If the last address was not at the current PC, advance to current. */
1123 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
1124 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
1125 != frag_now_fix ()))
1126 cfi_add_advance_loc (symbol_temp_new_now ());
1128 insn_ptr
= alloc_cfi_insn_data ();
1129 insn_ptr
->insn
= CFI_val_encoded_addr
;
1131 insn_ptr
->u
.ea
.reg
= cfi_parse_reg ();
1133 cfi_parse_separator ();
1134 encoding
= cfi_parse_const ();
1135 if ((encoding
& 0xff) != encoding
1136 || ((encoding
& 0x70) != 0
1137 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1138 && (encoding
& 0x70) != DW_EH_PE_pcrel
1141 /* leb128 can be handled, but does something actually need it? */
1142 || (encoding
& 7) == DW_EH_PE_uleb128
1143 || (encoding
& 7) > DW_EH_PE_udata8
)
1145 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1146 encoding
= DW_EH_PE_omit
;
1149 cfi_parse_separator ();
1150 expression_and_evaluate (&insn_ptr
->u
.ea
.exp
);
1151 switch (insn_ptr
->u
.ea
.exp
.X_op
)
1156 if ((encoding
& 0x70) != DW_EH_PE_pcrel
)
1160 encoding
= DW_EH_PE_omit
;
1164 insn_ptr
->u
.ea
.encoding
= encoding
;
1165 if (encoding
== DW_EH_PE_omit
)
1167 as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1168 ignore_rest_of_line ();
1172 demand_empty_rest_of_line ();
1176 dot_cfi_label (int ignored ATTRIBUTE_UNUSED
)
1180 if (frchain_now
->frch_cfi_data
== NULL
)
1182 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1183 ignore_rest_of_line ();
1187 name
= read_symbol_name ();
1191 /* If the last address was not at the current PC, advance to current. */
1192 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
1193 || (S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
1194 != frag_now_fix ()))
1195 cfi_add_advance_loc (symbol_temp_new_now ());
1197 cfi_add_label (name
);
1200 demand_empty_rest_of_line ();
1204 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED
)
1209 if (is_name_beginner (*input_line_pointer
) || *input_line_pointer
== '"')
1215 saved_ilp
= input_line_pointer
;
1216 c
= get_symbol_name (& name
);
1218 if (startswith (name
, ".eh_frame")
1220 sections
|= CFI_EMIT_eh_frame
;
1221 else if (startswith (name
, ".debug_frame"))
1222 sections
|= CFI_EMIT_debug_frame
;
1223 #if SUPPORT_COMPACT_EH
1224 else if (startswith (name
, ".eh_frame_entry"))
1227 sections
|= CFI_EMIT_eh_frame_compact
;
1230 #ifdef tc_cfi_section_name
1231 else if (strcmp (name
, tc_cfi_section_name
) == 0)
1232 sections
|= CFI_EMIT_target
;
1236 *input_line_pointer
= c
;
1237 input_line_pointer
= saved_ilp
;
1241 *input_line_pointer
= c
;
1242 SKIP_WHITESPACE_AFTER_NAME ();
1243 if (*input_line_pointer
== ',')
1245 name
= input_line_pointer
++;
1247 if (!is_name_beginner (*input_line_pointer
)
1248 && *input_line_pointer
!= '"')
1250 input_line_pointer
= name
;
1254 else if (is_name_beginner (*input_line_pointer
)
1255 || *input_line_pointer
== '"')
1259 demand_empty_rest_of_line ();
1260 if (cfi_sections_set
1261 && (sections
& (CFI_EMIT_eh_frame
| CFI_EMIT_eh_frame_compact
))
1262 && ((cfi_sections
& (CFI_EMIT_eh_frame
| CFI_EMIT_eh_frame_compact
))
1263 != (sections
& (CFI_EMIT_eh_frame
| CFI_EMIT_eh_frame_compact
))))
1264 as_bad (_("inconsistent uses of .cfi_sections"));
1265 cfi_sections
= sections
;
1269 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED
)
1273 if (frchain_now
->frch_cfi_data
!= NULL
)
1275 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1276 ignore_rest_of_line ();
1280 cfi_new_fde (symbol_temp_new_now ());
1283 if (is_name_beginner (*input_line_pointer
) || *input_line_pointer
== '"')
1285 char * saved_ilp
= input_line_pointer
;
1288 c
= get_symbol_name (& name
);
1290 if (strcmp (name
, "simple") == 0)
1293 restore_line_pointer (c
);
1296 input_line_pointer
= saved_ilp
;
1298 demand_empty_rest_of_line ();
1300 cfi_sections_set
= true;
1301 all_cfi_sections
|= cfi_sections
;
1302 cfi_set_sections ();
1303 frchain_now
->frch_cfi_data
->cur_cfa_offset
= 0;
1305 tc_cfi_frame_initial_instructions ();
1307 if ((cfi_sections
& CFI_EMIT_target
) != 0)
1308 tc_cfi_startproc ();
1312 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED
)
1314 if (frchain_now
->frch_cfi_data
== NULL
)
1316 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1317 ignore_rest_of_line ();
1321 last_fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1323 cfi_end_fde (symbol_temp_new_now ());
1325 demand_empty_rest_of_line ();
1327 cfi_sections_set
= true;
1328 if ((cfi_sections
& CFI_EMIT_target
) != 0)
1329 tc_cfi_endproc (last_fde
);
1333 get_cfi_seg (segT cseg
, const char *base
, flagword flags
, int align
)
1335 /* Exclude .debug_frame sections for Compact EH. */
1336 if (SUPPORT_FRAME_LINKONCE
|| ((flags
& SEC_DEBUGGING
) == 0 && compact_eh
))
1338 struct dwcfi_seg_list
*l
;
1340 l
= dwcfi_hash_find_or_make (cseg
, base
, flags
);
1343 subseg_set (cseg
, l
->subseg
);
1347 cseg
= subseg_new (base
, 0);
1348 bfd_set_section_flags (cseg
, flags
);
1350 record_alignment (cseg
, align
);
1354 #if SUPPORT_COMPACT_EH
1356 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED
)
1358 struct fde_entry
*fde
;
1360 if (frchain_now
->frch_cfi_data
== NULL
)
1362 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1363 ignore_rest_of_line ();
1367 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1368 fde
->personality_id
= cfi_parse_const ();
1369 demand_empty_rest_of_line ();
1371 if (fde
->personality_id
== 0 || fde
->personality_id
> 3)
1373 as_bad (_("wrong argument to .cfi_personality_id"));
1379 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED
)
1381 if (frchain_now
->frch_cfi_data
== NULL
)
1383 as_bad (_(".cfi_fde_data without corresponding .cfi_startproc"));
1384 ignore_rest_of_line ();
1388 last_fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
1390 cfi_sections_set
= true;
1391 if ((cfi_sections
& CFI_EMIT_target
) != 0
1392 || (cfi_sections
& CFI_EMIT_eh_frame_compact
) != 0)
1394 struct cfi_escape_data
*head
, **tail
, *e
;
1398 if (!is_it_end_of_statement ())
1403 e
= XNEW (struct cfi_escape_data
);
1404 do_parse_cons_expression (&e
->exp
, 1);
1409 while (*input_line_pointer
++ == ',');
1410 --input_line_pointer
;
1414 if (last_fde
->lsda_encoding
!= DW_EH_PE_omit
)
1415 last_fde
->eh_header_type
= EH_COMPACT_HAS_LSDA
;
1416 else if (num_ops
<= 3 && last_fde
->per_encoding
== DW_EH_PE_omit
)
1417 last_fde
->eh_header_type
= EH_COMPACT_INLINE
;
1419 last_fde
->eh_header_type
= EH_COMPACT_OUTLINE
;
1421 if (last_fde
->eh_header_type
== EH_COMPACT_INLINE
)
1424 last_fde
->eh_data_size
= num_ops
;
1425 last_fde
->eh_data
= XNEWVEC (bfd_byte
, num_ops
);
1431 last_fde
->eh_data
[num_ops
++] = e
->exp
.X_add_number
;
1434 if (last_fde
->eh_header_type
== EH_COMPACT_INLINE
)
1436 last_fde
->eh_data
[num_ops
++] = tc_compact_eh_opcode_stop
;
1439 demand_empty_rest_of_line ();
1442 /* Function to emit the compact unwinding opcodes stored in the
1443 fde's eh_data field. The end of the opcode data will be
1444 padded to the value in align. */
1447 output_compact_unwind_data (struct fde_entry
*fde
, int align
)
1449 int data_size
= fde
->eh_data_size
+ 2;
1454 fde
->eh_loc
= symbol_temp_new_now ();
1457 if (fde
->personality_id
!= 0)
1458 *p
= fde
->personality_id
;
1459 else if (fde
->per_encoding
!= DW_EH_PE_omit
)
1462 emit_expr_encoded (&fde
->personality
, fde
->per_encoding
, false);
1463 data_size
+= encoding_size (fde
->per_encoding
);
1468 amask
= (1 << align
) - 1;
1469 align_padding
= ((data_size
+ amask
) & ~amask
) - data_size
;
1471 p
= frag_more (fde
->eh_data_size
+ 1 + align_padding
);
1472 memcpy (p
, fde
->eh_data
, fde
->eh_data_size
);
1473 p
+= fde
->eh_data_size
;
1475 while (align_padding
-- > 0)
1476 *(p
++) = tc_compact_eh_opcode_pad
;
1478 *(p
++) = tc_compact_eh_opcode_stop
;
1479 fde
->eh_header_type
= EH_COMPACT_OUTLINE_DONE
;
1482 /* Handle the .cfi_inline_lsda directive. */
1484 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED
)
1488 long max_alignment
= 28;
1492 as_bad (_("unexpected .cfi_inline_lsda"));
1493 ignore_rest_of_line ();
1497 if ((last_fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
1499 as_bad (_(".cfi_inline_lsda not valid for this frame"));
1500 ignore_rest_of_line ();
1504 if (last_fde
->eh_header_type
!= EH_COMPACT_UNKNOWN
1505 && last_fde
->eh_header_type
!= EH_COMPACT_HAS_LSDA
)
1507 as_bad (_(".cfi_inline_lsda seen for frame without .cfi_lsda"));
1508 ignore_rest_of_line ();
1512 #ifdef md_flush_pending_output
1513 md_flush_pending_output ();
1516 align
= get_absolute_expression ();
1517 if (align
> max_alignment
)
1519 align
= max_alignment
;
1520 as_bad (_("Alignment too large: %d. assumed."), align
);
1524 as_warn (_("Alignment negative: 0 assumed."));
1528 demand_empty_rest_of_line ();
1529 ccseg
= CUR_SEG (last_fde
);
1531 /* Open .gnu_extab section. */
1532 get_cfi_seg (ccseg
, ".gnu_extab",
1533 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
1534 | DWARF2_EH_FRAME_READ_ONLY
),
1537 frag_align (align
, 0, 0);
1538 record_alignment (now_seg
, align
);
1539 if (last_fde
->eh_header_type
== EH_COMPACT_HAS_LSDA
)
1540 output_compact_unwind_data (last_fde
, align
);
1546 #else /* !SUPPORT_COMPACT_EH */
1548 dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED
)
1550 as_bad (_(".cfi_inline_lsda is not supported for this target"));
1551 ignore_rest_of_line ();
1555 dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED
)
1557 as_bad (_(".cfi_fde_data is not supported for this target"));
1558 ignore_rest_of_line ();
1562 dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED
)
1564 as_bad (_(".cfi_personality_id is not supported for this target"));
1565 ignore_rest_of_line ();
1570 output_cfi_insn (struct cfi_insn_data
*insn
)
1577 case DW_CFA_advance_loc
:
1579 symbolS
*from
= insn
->u
.ll
.lab1
;
1580 symbolS
*to
= insn
->u
.ll
.lab2
;
1582 if (symbol_get_frag (to
) == symbol_get_frag (from
))
1584 addressT delta
= S_GET_VALUE (to
) - S_GET_VALUE (from
);
1585 addressT scaled
= delta
/ DWARF2_LINE_MIN_INSN_LENGTH
;
1589 else if (scaled
<= 0x3F)
1590 out_one (DW_CFA_advance_loc
+ scaled
);
1591 else if (scaled
<= 0xFF)
1593 out_one (DW_CFA_advance_loc1
);
1596 else if (scaled
<= 0xFFFF)
1598 out_one (DW_CFA_advance_loc2
);
1603 out_one (DW_CFA_advance_loc4
);
1611 exp
.X_op
= O_subtract
;
1612 exp
.X_add_symbol
= to
;
1613 exp
.X_op_symbol
= from
;
1614 exp
.X_add_number
= 0;
1616 /* The code in ehopt.c expects that one byte of the encoding
1617 is already allocated to the frag. This comes from the way
1618 that it scans the .eh_frame section looking first for the
1619 .byte DW_CFA_advance_loc4. Call frag_grow with the sum of
1620 room needed by frag_more and frag_var to preallocate space
1621 ensuring that the DW_CFA_advance_loc4 is in the fixed part
1622 of the rs_cfa frag, so that the relax machinery can remove
1623 the advance_loc should it advance by zero. */
1625 *frag_more (1) = DW_CFA_advance_loc4
;
1627 frag_var (rs_cfa
, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH
<< 3,
1628 make_expr_symbol (&exp
), frag_now_fix () - 1,
1634 case DW_CFA_def_cfa
:
1635 offset
= insn
->u
.ri
.offset
;
1638 out_one (DW_CFA_def_cfa_sf
);
1639 out_uleb128 (insn
->u
.ri
.reg
);
1640 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1644 out_one (DW_CFA_def_cfa
);
1645 out_uleb128 (insn
->u
.ri
.reg
);
1646 out_uleb128 (offset
);
1650 case DW_CFA_def_cfa_register
:
1651 case DW_CFA_undefined
:
1652 case DW_CFA_same_value
:
1653 out_one (insn
->insn
);
1654 out_uleb128 (insn
->u
.r
);
1657 case DW_CFA_def_cfa_offset
:
1661 out_one (DW_CFA_def_cfa_offset_sf
);
1662 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1666 out_one (DW_CFA_def_cfa_offset
);
1667 out_uleb128 (offset
);
1671 case DW_CFA_restore
:
1675 out_one (DW_CFA_restore
+ regno
);
1679 out_one (DW_CFA_restore_extended
);
1680 out_uleb128 (regno
);
1685 regno
= insn
->u
.ri
.reg
;
1686 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
1689 out_one (DW_CFA_offset_extended_sf
);
1690 out_uleb128 (regno
);
1691 out_sleb128 (offset
);
1693 else if (regno
<= 0x3F)
1695 out_one (DW_CFA_offset
+ regno
);
1696 out_uleb128 (offset
);
1700 out_one (DW_CFA_offset_extended
);
1701 out_uleb128 (regno
);
1702 out_uleb128 (offset
);
1706 case DW_CFA_val_offset
:
1707 regno
= insn
->u
.ri
.reg
;
1708 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
1711 out_one (DW_CFA_val_offset_sf
);
1712 out_uleb128 (regno
);
1713 out_sleb128 (offset
);
1717 out_one (DW_CFA_val_offset
);
1718 out_uleb128 (regno
);
1719 out_uleb128 (offset
);
1723 case DW_CFA_register
:
1724 out_one (DW_CFA_register
);
1725 out_uleb128 (insn
->u
.rr
.reg1
);
1726 out_uleb128 (insn
->u
.rr
.reg2
);
1729 case DW_CFA_remember_state
:
1730 case DW_CFA_restore_state
:
1731 out_one (insn
->insn
);
1734 case DW_CFA_GNU_window_save
:
1735 out_one (DW_CFA_GNU_window_save
);
1740 struct cfi_escape_data
*e
;
1741 for (e
= insn
->u
.esc
; e
; e
= e
->next
)
1742 emit_expr (&e
->exp
, 1);
1746 case CFI_val_encoded_addr
:
1748 unsigned encoding
= insn
->u
.ea
.encoding
;
1751 if (encoding
== DW_EH_PE_omit
)
1753 out_one (DW_CFA_val_expression
);
1754 out_uleb128 (insn
->u
.ea
.reg
);
1756 switch (encoding
& 0x7)
1758 case DW_EH_PE_absptr
:
1759 enc_size
= DWARF2_ADDR_SIZE (stdoutput
);
1761 case DW_EH_PE_udata2
:
1764 case DW_EH_PE_udata4
:
1767 case DW_EH_PE_udata8
:
1774 /* If the user has requested absolute encoding,
1775 then use the smaller DW_OP_addr encoding. */
1776 if (insn
->u
.ea
.encoding
== DW_EH_PE_absptr
)
1778 out_uleb128 (1 + enc_size
);
1779 out_one (DW_OP_addr
);
1783 out_uleb128 (1 + 1 + enc_size
);
1784 out_one (DW_OP_GNU_encoded_addr
);
1787 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1789 #if CFI_DIFF_EXPR_OK
1790 insn
->u
.ea
.exp
.X_op
= O_subtract
;
1791 insn
->u
.ea
.exp
.X_op_symbol
= symbol_temp_new_now ();
1792 #elif defined (tc_cfi_emit_pcrel_expr)
1793 tc_cfi_emit_pcrel_expr (&insn
->u
.ea
.exp
, enc_size
);
1800 emit_expr (&insn
->u
.ea
.exp
, enc_size
);
1805 colon (insn
->u
.sym_name
);
1814 output_cie (struct cie_entry
*cie
, bool eh_frame
, int align
)
1816 symbolS
*after_size_address
, *end_address
;
1818 struct cfi_insn_data
*i
;
1819 offsetT augmentation_size
;
1821 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1823 cie
->start_address
= symbol_temp_new_now ();
1824 after_size_address
= symbol_temp_make ();
1825 end_address
= symbol_temp_make ();
1827 exp
.X_op
= O_subtract
;
1828 exp
.X_add_symbol
= end_address
;
1829 exp
.X_op_symbol
= after_size_address
;
1830 exp
.X_add_number
= 0;
1832 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1833 emit_expr (&exp
, 4); /* Length. */
1836 if (fmt
== dwarf2_format_64bit
)
1838 emit_expr (&exp
, 8); /* Length. */
1840 symbol_set_value_now (after_size_address
);
1842 out_four (0); /* CIE id. */
1845 out_four (-1); /* CIE id. */
1846 if (fmt
!= dwarf2_format_32bit
)
1849 out_one (flag_dwarf_cie_version
); /* Version. */
1852 out_one ('z'); /* Augmentation. */
1853 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1855 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1858 #ifdef tc_output_cie_extra
1859 tc_output_cie_extra (cie
);
1862 if (cie
->signal_frame
)
1865 if (flag_dwarf_cie_version
>= 4)
1867 /* For now we are assuming a flat address space with 4 or 8 byte
1869 int address_size
= dwarf2_format_32bit
? 4 : 8;
1870 out_one (address_size
); /* Address size. */
1871 out_one (0); /* Segment size. */
1873 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH
); /* Code alignment. */
1874 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT
); /* Data alignment. */
1875 if (flag_dwarf_cie_version
== 1) /* Return column. */
1877 if ((cie
->return_column
& 0xff) != cie
->return_column
)
1878 as_bad (_("return column number %d overflows in CIE version 1"),
1879 cie
->return_column
);
1880 out_one (cie
->return_column
);
1883 out_uleb128 (cie
->return_column
);
1886 augmentation_size
= 1 + (cie
->lsda_encoding
!= DW_EH_PE_omit
);
1887 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1888 augmentation_size
+= 1 + encoding_size (cie
->per_encoding
);
1889 out_uleb128 (augmentation_size
); /* Augmentation size. */
1891 emit_expr_encoded (&cie
->personality
, cie
->per_encoding
, true);
1893 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1894 out_one (cie
->lsda_encoding
);
1897 switch (DWARF2_FDE_RELOC_SIZE
)
1900 enc
= DW_EH_PE_sdata2
;
1903 enc
= DW_EH_PE_sdata4
;
1906 enc
= DW_EH_PE_sdata8
;
1911 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1912 enc
|= DW_EH_PE_pcrel
;
1914 #ifdef DWARF2_FDE_RELOC_ENCODING
1915 /* Allow target to override encoding. */
1916 enc
= DWARF2_FDE_RELOC_ENCODING (enc
);
1918 cie
->fde_encoding
= enc
;
1924 for (i
= cie
->first
; i
!= cie
->last
; i
= i
->next
)
1926 if (CUR_SEG (i
) != CUR_SEG (cie
))
1928 output_cfi_insn (i
);
1932 frag_align (align
, DW_CFA_nop
, 0);
1933 symbol_set_value_now (end_address
);
1937 output_fde (struct fde_entry
*fde
, struct cie_entry
*cie
,
1938 bool eh_frame
, struct cfi_insn_data
*first
,
1941 symbolS
*after_size_address
, *end_address
;
1943 offsetT augmentation_size
;
1944 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1945 unsigned int offset_size
;
1946 unsigned int addr_size
;
1948 after_size_address
= symbol_temp_make ();
1949 end_address
= symbol_temp_make ();
1951 exp
.X_op
= O_subtract
;
1952 exp
.X_add_symbol
= end_address
;
1953 exp
.X_op_symbol
= after_size_address
;
1954 exp
.X_add_number
= 0;
1955 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1959 if (fmt
== dwarf2_format_64bit
)
1963 emit_expr (&exp
, offset_size
); /* Length. */
1964 symbol_set_value_now (after_size_address
);
1968 exp
.X_op
= O_subtract
;
1969 exp
.X_add_symbol
= after_size_address
;
1970 exp
.X_op_symbol
= cie
->start_address
;
1971 exp
.X_add_number
= 0;
1972 emit_expr (&exp
, offset_size
); /* CIE offset. */
1976 TC_DWARF2_EMIT_OFFSET (cie
->start_address
, offset_size
);
1979 exp
.X_op
= O_symbol
;
1982 bfd_reloc_code_real_type code
1983 = tc_cfi_reloc_for_encoding (cie
->fde_encoding
);
1984 addr_size
= DWARF2_FDE_RELOC_SIZE
;
1985 if (code
!= BFD_RELOC_NONE
)
1987 reloc_howto_type
*howto
= bfd_reloc_type_lookup (stdoutput
, code
);
1988 char *p
= frag_more (addr_size
);
1989 gas_assert (addr_size
== (unsigned) howto
->bitsize
/ 8);
1990 md_number_to_chars (p
, 0, addr_size
);
1991 fix_new (frag_now
, p
- frag_now
->fr_literal
, addr_size
,
1992 fde
->start_address
, 0, howto
->pc_relative
, code
);
1996 exp
.X_op
= O_subtract
;
1997 exp
.X_add_number
= 0;
1998 #if CFI_DIFF_EXPR_OK
1999 exp
.X_add_symbol
= fde
->start_address
;
2000 exp
.X_op_symbol
= symbol_temp_new_now ();
2001 emit_expr (&exp
, addr_size
); /* Code offset. */
2003 exp
.X_op
= O_symbol
;
2004 exp
.X_add_symbol
= fde
->start_address
;
2006 #if defined(tc_cfi_emit_pcrel_expr)
2007 tc_cfi_emit_pcrel_expr (&exp
, addr_size
); /* Code offset. */
2009 emit_expr (&exp
, addr_size
); /* Code offset. */
2016 exp
.X_add_number
= 0;
2017 exp
.X_add_symbol
= fde
->start_address
;
2018 addr_size
= DWARF2_ADDR_SIZE (stdoutput
);
2019 emit_expr (&exp
, addr_size
);
2022 exp
.X_op
= O_subtract
;
2023 exp
.X_add_symbol
= fde
->end_address
;
2024 exp
.X_op_symbol
= fde
->start_address
; /* Code length. */
2025 exp
.X_add_number
= 0;
2026 emit_expr (&exp
, addr_size
);
2028 augmentation_size
= encoding_size (fde
->lsda_encoding
);
2030 out_uleb128 (augmentation_size
); /* Augmentation size. */
2032 emit_expr_encoded (&fde
->lsda
, cie
->lsda_encoding
, false);
2034 for (; first
; first
= first
->next
)
2035 if (CUR_SEG (first
) == CUR_SEG (fde
))
2036 output_cfi_insn (first
);
2038 frag_align (align
, DW_CFA_nop
, 0);
2039 symbol_set_value_now (end_address
);
2042 /* Allow these insns to be put in the initial sequence of a CIE.
2043 If J is non-NULL, then compare I and J insns for a match. */
2046 initial_cie_insn (const struct cfi_insn_data
*i
, const struct cfi_insn_data
*j
)
2048 if (j
&& i
->insn
!= j
->insn
)
2053 case DW_CFA_def_cfa
:
2054 case DW_CFA_val_offset
:
2057 if (i
->u
.ri
.reg
!= j
->u
.ri
.reg
)
2059 if (i
->u
.ri
.offset
!= j
->u
.ri
.offset
)
2064 case DW_CFA_register
:
2067 if (i
->u
.rr
.reg1
!= j
->u
.rr
.reg1
)
2069 if (i
->u
.rr
.reg2
!= j
->u
.rr
.reg2
)
2074 case DW_CFA_def_cfa_register
:
2075 case DW_CFA_restore
:
2076 case DW_CFA_undefined
:
2077 case DW_CFA_same_value
:
2080 if (i
->u
.r
!= j
->u
.r
)
2085 case DW_CFA_def_cfa_offset
:
2088 if (i
->u
.i
!= j
->u
.i
)
2099 static struct cie_entry
*
2100 select_cie_for_fde (struct fde_entry
*fde
, bool eh_frame
,
2101 struct cfi_insn_data
**pfirst
, int align
)
2103 struct cfi_insn_data
*i
, *j
;
2104 struct cie_entry
*cie
;
2106 for (cie
= cie_root
; cie
; cie
= cie
->next
)
2108 if (CUR_SEG (cie
) != CUR_SEG (fde
))
2110 #ifdef tc_cie_fde_equivalent_extra
2111 if (!tc_cie_fde_equivalent_extra (cie
, fde
))
2114 if (cie
->return_column
!= fde
->return_column
2115 || cie
->signal_frame
!= fde
->signal_frame
2116 || cie
->per_encoding
!= fde
->per_encoding
2117 || cie
->lsda_encoding
!= fde
->lsda_encoding
)
2119 if (cie
->per_encoding
!= DW_EH_PE_omit
)
2121 if (cie
->personality
.X_op
!= fde
->personality
.X_op
2122 || (cie
->personality
.X_add_number
2123 != fde
->personality
.X_add_number
))
2125 switch (cie
->personality
.X_op
)
2128 if (cie
->personality
.X_unsigned
!= fde
->personality
.X_unsigned
)
2132 if (cie
->personality
.X_add_symbol
2133 != fde
->personality
.X_add_symbol
)
2140 for (i
= cie
->first
, j
= fde
->data
;
2141 i
!= cie
->last
&& j
!= NULL
;
2142 i
= i
->next
, j
= j
->next
)
2144 if (!initial_cie_insn (i
, j
))
2155 cie
= XNEW (struct cie_entry
);
2156 cie
->next
= cie_root
;
2158 SET_CUR_SEG (cie
, CUR_SEG (fde
));
2159 cie
->return_column
= fde
->return_column
;
2160 cie
->signal_frame
= fde
->signal_frame
;
2161 cie
->per_encoding
= fde
->per_encoding
;
2162 cie
->lsda_encoding
= fde
->lsda_encoding
;
2163 cie
->personality
= fde
->personality
;
2164 cie
->first
= fde
->data
;
2165 #ifdef tc_cie_entry_init_extra
2166 tc_cie_entry_init_extra (cie
, fde
)
2169 for (i
= cie
->first
; i
; i
= i
->next
)
2170 if (!initial_cie_insn (i
, NULL
))
2176 output_cie (cie
, eh_frame
, align
);
2181 #ifdef md_reg_eh_frame_to_debug_frame
2183 cfi_change_reg_numbers (struct cfi_insn_data
*insn
, segT ccseg
)
2185 for (; insn
; insn
= insn
->next
)
2187 if (CUR_SEG (insn
) != ccseg
)
2191 case DW_CFA_advance_loc
:
2192 case DW_CFA_def_cfa_offset
:
2193 case DW_CFA_remember_state
:
2194 case DW_CFA_restore_state
:
2195 case DW_CFA_GNU_window_save
:
2200 case DW_CFA_def_cfa
:
2202 insn
->u
.ri
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ri
.reg
);
2205 case DW_CFA_def_cfa_register
:
2206 case DW_CFA_undefined
:
2207 case DW_CFA_same_value
:
2208 case DW_CFA_restore
:
2209 insn
->u
.r
= md_reg_eh_frame_to_debug_frame (insn
->u
.r
);
2212 case DW_CFA_register
:
2213 insn
->u
.rr
.reg1
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg1
);
2214 insn
->u
.rr
.reg2
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg2
);
2217 case CFI_val_encoded_addr
:
2218 insn
->u
.ea
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ea
.reg
);
2227 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
2230 #if SUPPORT_COMPACT_EH
2232 cfi_emit_eh_header (symbolS
*sym
, bfd_vma addend
)
2236 exp
.X_add_number
= addend
;
2237 exp
.X_add_symbol
= sym
;
2238 emit_expr_encoded (&exp
, DW_EH_PE_sdata4
| DW_EH_PE_pcrel
, false);
2242 output_eh_header (struct fde_entry
*fde
)
2247 if (fde
->eh_header_type
== EH_COMPACT_INLINE
)
2252 cfi_emit_eh_header (fde
->start_address
, addend
);
2254 if (fde
->eh_header_type
== EH_COMPACT_INLINE
)
2257 /* Inline entries always use PR1. */
2259 memcpy(p
, fde
->eh_data
, 3);
2263 if (fde
->eh_header_type
== EH_COMPACT_LEGACY
)
2265 else if (fde
->eh_header_type
== EH_COMPACT_OUTLINE
2266 || fde
->eh_header_type
== EH_COMPACT_OUTLINE_DONE
)
2270 cfi_emit_eh_header (fde
->eh_loc
, addend
);
2278 struct cie_entry
*cie
, *cie_next
;
2279 segT cfi_seg
, ccseg
;
2280 struct fde_entry
*fde
;
2281 struct cfi_insn_data
*first
;
2282 int save_flag_traditional_format
, seek_next_seg
;
2284 if (all_fde_data
== 0)
2287 cfi_sections_set
= true;
2288 if ((all_cfi_sections
& CFI_EMIT_eh_frame
) != 0
2289 || (all_cfi_sections
& CFI_EMIT_eh_frame_compact
) != 0)
2291 /* Make sure check_eh_frame doesn't do anything with our output. */
2292 save_flag_traditional_format
= flag_traditional_format
;
2293 flag_traditional_format
= 1;
2295 if (!EH_FRAME_LINKONCE
)
2297 /* Open .eh_frame section. */
2298 cfi_seg
= get_cfi_seg (NULL
, ".eh_frame",
2299 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2300 | DWARF2_EH_FRAME_READ_ONLY
),
2301 EH_FRAME_ALIGNMENT
);
2302 #ifdef md_fix_up_eh_frame
2303 md_fix_up_eh_frame (cfi_seg
);
2314 for (cie
= cie_root
; cie
; cie
= cie_next
)
2316 cie_next
= cie
->next
;
2317 free ((void *) cie
);
2321 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2323 if ((fde
->sections
& CFI_EMIT_eh_frame
) == 0
2324 && (fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
2327 #if SUPPORT_COMPACT_EH
2328 /* Emit a LEGACY format header if we have processed all
2329 of the .cfi directives without encountering either inline or
2330 out-of-line compact unwinding opcodes. */
2331 if (fde
->eh_header_type
== EH_COMPACT_HAS_LSDA
2332 || fde
->eh_header_type
== EH_COMPACT_UNKNOWN
)
2333 fde
->eh_header_type
= EH_COMPACT_LEGACY
;
2335 if (fde
->eh_header_type
!= EH_COMPACT_LEGACY
)
2338 if (EH_FRAME_LINKONCE
)
2342 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2349 ccseg
= CUR_SEG (fde
);
2350 /* Open .eh_frame section. */
2351 cfi_seg
= get_cfi_seg (ccseg
, ".eh_frame",
2352 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2353 | DWARF2_EH_FRAME_READ_ONLY
),
2354 EH_FRAME_ALIGNMENT
);
2355 #ifdef md_fix_up_eh_frame
2356 md_fix_up_eh_frame (cfi_seg
);
2362 SET_HANDLED (fde
, 1);
2365 if (fde
->end_address
== NULL
)
2367 as_bad (_("open CFI at the end of file; "
2368 "missing .cfi_endproc directive"));
2369 fde
->end_address
= fde
->start_address
;
2372 cie
= select_cie_for_fde (fde
, true, &first
, 2);
2373 fde
->eh_loc
= symbol_temp_new_now ();
2374 output_fde (fde
, cie
, true, first
,
2375 fde
->next
== NULL
? EH_FRAME_ALIGNMENT
: 2);
2378 while (EH_FRAME_LINKONCE
&& seek_next_seg
== 2);
2380 if (EH_FRAME_LINKONCE
)
2381 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2382 SET_HANDLED (fde
, 0);
2384 #if SUPPORT_COMPACT_EH
2387 /* Create remaining out of line table entries. */
2393 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2395 if ((fde
->sections
& CFI_EMIT_eh_frame
) == 0
2396 && (fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
2399 if (fde
->eh_header_type
!= EH_COMPACT_OUTLINE
)
2403 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2410 ccseg
= CUR_SEG (fde
);
2411 /* Open .gnu_extab section. */
2412 get_cfi_seg (ccseg
, ".gnu_extab",
2413 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2414 | DWARF2_EH_FRAME_READ_ONLY
),
2418 SET_HANDLED (fde
, 1);
2420 frag_align (1, 0, 0);
2421 record_alignment (now_seg
, 1);
2422 output_compact_unwind_data (fde
, 1);
2425 while (EH_FRAME_LINKONCE
&& seek_next_seg
== 2);
2427 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2428 SET_HANDLED (fde
, 0);
2430 /* Create index table fragments. */
2436 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2438 if ((fde
->sections
& CFI_EMIT_eh_frame
) == 0
2439 && (fde
->sections
& CFI_EMIT_eh_frame_compact
) == 0)
2444 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2451 ccseg
= CUR_SEG (fde
);
2452 /* Open .eh_frame_entry section. */
2453 cfi_seg
= get_cfi_seg (ccseg
, ".eh_frame_entry",
2454 (SEC_ALLOC
| SEC_LOAD
| SEC_DATA
2455 | DWARF2_EH_FRAME_READ_ONLY
),
2459 SET_HANDLED (fde
, 1);
2461 output_eh_header (fde
);
2464 while (seek_next_seg
== 2);
2466 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2467 SET_HANDLED (fde
, 0);
2469 #endif /* SUPPORT_COMPACT_EH */
2471 flag_traditional_format
= save_flag_traditional_format
;
2474 cfi_sections_set
= true;
2475 if ((all_cfi_sections
& CFI_EMIT_debug_frame
) != 0)
2477 int alignment
= ffs (DWARF2_ADDR_SIZE (stdoutput
)) - 1;
2479 if (!SUPPORT_FRAME_LINKONCE
)
2480 get_cfi_seg (NULL
, ".debug_frame",
2481 SEC_READONLY
| SEC_DEBUGGING
,
2489 for (cie
= cie_root
; cie
; cie
= cie_next
)
2491 cie_next
= cie
->next
;
2492 free ((void *) cie
);
2496 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2498 if ((fde
->sections
& CFI_EMIT_debug_frame
) == 0)
2501 if (SUPPORT_FRAME_LINKONCE
)
2505 if (seek_next_seg
&& CUR_SEG (fde
) != ccseg
)
2512 ccseg
= CUR_SEG (fde
);
2513 /* Open .debug_frame section. */
2514 get_cfi_seg (ccseg
, ".debug_frame",
2515 SEC_READONLY
| SEC_DEBUGGING
,
2519 SET_HANDLED (fde
, 1);
2521 if (fde
->end_address
== NULL
)
2523 as_bad (_("open CFI at the end of file; "
2524 "missing .cfi_endproc directive"));
2525 fde
->end_address
= fde
->start_address
;
2528 fde
->per_encoding
= DW_EH_PE_omit
;
2529 fde
->lsda_encoding
= DW_EH_PE_omit
;
2530 cfi_change_reg_numbers (fde
->data
, ccseg
);
2531 cie
= select_cie_for_fde (fde
, false, &first
, alignment
);
2532 output_fde (fde
, cie
, false, first
, alignment
);
2535 while (SUPPORT_FRAME_LINKONCE
&& seek_next_seg
== 2);
2537 if (SUPPORT_FRAME_LINKONCE
)
2538 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
2539 SET_HANDLED (fde
, 0);
2542 htab_delete (dwcfi_hash
);
2545 #else /* TARGET_USE_CFIPOP */
2547 /* Emit an intelligible error message for missing support. */
2550 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED
)
2552 as_bad (_("CFI is not supported for this target"));
2553 ignore_rest_of_line ();
2556 const pseudo_typeS cfi_pseudo_table
[] =
2558 { "cfi_sections", dot_cfi_dummy
, 0 },
2559 { "cfi_startproc", dot_cfi_dummy
, 0 },
2560 { "cfi_endproc", dot_cfi_dummy
, 0 },
2561 { "cfi_fde_data", dot_cfi_dummy
, 0 },
2562 { "cfi_def_cfa", dot_cfi_dummy
, 0 },
2563 { "cfi_def_cfa_register", dot_cfi_dummy
, 0 },
2564 { "cfi_def_cfa_offset", dot_cfi_dummy
, 0 },
2565 { "cfi_adjust_cfa_offset", dot_cfi_dummy
, 0 },
2566 { "cfi_offset", dot_cfi_dummy
, 0 },
2567 { "cfi_rel_offset", dot_cfi_dummy
, 0 },
2568 { "cfi_register", dot_cfi_dummy
, 0 },
2569 { "cfi_return_column", dot_cfi_dummy
, 0 },
2570 { "cfi_restore", dot_cfi_dummy
, 0 },
2571 { "cfi_undefined", dot_cfi_dummy
, 0 },
2572 { "cfi_same_value", dot_cfi_dummy
, 0 },
2573 { "cfi_remember_state", dot_cfi_dummy
, 0 },
2574 { "cfi_restore_state", dot_cfi_dummy
, 0 },
2575 { "cfi_window_save", dot_cfi_dummy
, 0 },
2576 { "cfi_escape", dot_cfi_dummy
, 0 },
2577 { "cfi_signal_frame", dot_cfi_dummy
, 0 },
2578 { "cfi_personality", dot_cfi_dummy
, 0 },
2579 { "cfi_personality_id", dot_cfi_dummy
, 0 },
2580 { "cfi_lsda", dot_cfi_dummy
, 0 },
2581 { "cfi_val_encoded_addr", dot_cfi_dummy
, 0 },
2582 { "cfi_label", dot_cfi_dummy
, 0 },
2583 { "cfi_inline_lsda", dot_cfi_dummy
, 0 },
2584 { "cfi_val_offset", dot_cfi_dummy
, 0 },
2592 #endif /* TARGET_USE_CFIPOP */