1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
3 Free Software Foundation, Inc.
4 Contributed by Michal Ludvig <mludvig@suse.cz>
6 This file is part of GAS, the GNU Assembler.
8 GAS is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GAS is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GAS; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
24 #include "dw2gencfi.h"
26 #include "dwarf2dbg.h"
28 #ifdef TARGET_USE_CFIPOP
30 /* By default, use difference expressions if DIFF_EXPR_OK is defined. */
31 #ifndef CFI_DIFF_EXPR_OK
33 # define CFI_DIFF_EXPR_OK 1
35 # define CFI_DIFF_EXPR_OK 0
39 #ifndef CFI_DIFF_LSDA_OK
40 #define CFI_DIFF_LSDA_OK CFI_DIFF_EXPR_OK
43 #if CFI_DIFF_EXPR_OK == 1 && CFI_DIFF_LSDA_OK == 0
44 # error "CFI_DIFF_EXPR_OK should imply CFI_DIFF_LSDA_OK"
47 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
48 of the CIE. Default to 1 if not otherwise specified. */
49 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
50 #define DWARF2_LINE_MIN_INSN_LENGTH 1
53 /* By default, use 32-bit relocations from .eh_frame into .text. */
54 #ifndef DWARF2_FDE_RELOC_SIZE
55 #define DWARF2_FDE_RELOC_SIZE 4
58 /* By default, use a read-only .eh_frame section. */
59 #ifndef DWARF2_EH_FRAME_READ_ONLY
60 #define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY
63 #ifndef EH_FRAME_ALIGNMENT
64 #define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
67 #ifndef tc_cfi_frame_initial_instructions
68 #define tc_cfi_frame_initial_instructions() ((void)0)
72 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit
75 #ifndef DWARF2_ADDR_SIZE
76 #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
79 /* Private segment collection list. */
87 #define FRAME_NAME ".eh_frame"
89 static struct hash_control
*dwcfi_hash
;
91 /* Build based on segment the derived .debug_...
92 segment name containing origin segment's postfix name part. */
95 get_debugseg_name (segT seg
, const char *base_name
)
106 name
= bfd_get_section_name (stdoutput
, seg
);
108 dollar
= strchr (name
, '$');
109 dot
= strchr (name
+ 1, '.');
117 else if (dot
< dollar
)
123 return concat (base_name
, name
, NULL
);
126 /* Allocate a dwcfi_seg_list structure. */
128 static struct dwcfi_seg_list
*
129 alloc_debugseg_item (segT seg
, int subseg
, char *name
)
131 struct dwcfi_seg_list
*r
;
133 r
= (struct dwcfi_seg_list
*)
134 xmalloc (sizeof (struct dwcfi_seg_list
) + strlen (name
));
142 is_now_linkonce_segment (void)
144 #if defined (TE_PE) || defined (TE_PEP)
145 if ((bfd_get_section_flags (stdoutput
, now_seg
)
146 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
147 | SEC_LINK_DUPLICATES_ONE_ONLY
| SEC_LINK_DUPLICATES_SAME_SIZE
148 | SEC_LINK_DUPLICATES_SAME_CONTENTS
)) != 0)
154 /* Generate debug... segment with same linkonce properties
158 make_debug_seg (segT cseg
, char *name
, int sflags
)
160 segT save_seg
= now_seg
;
161 int save_subseg
= now_subseg
;
165 r
= subseg_new (name
, 0);
167 /* Check if code segment is marked as linked once. */
171 flags
= bfd_get_section_flags (stdoutput
, cseg
)
172 & (SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
173 | SEC_LINK_DUPLICATES_ONE_ONLY
| SEC_LINK_DUPLICATES_SAME_SIZE
174 | SEC_LINK_DUPLICATES_SAME_CONTENTS
);
176 /* Add standard section flags. */
179 /* Apply possibly linked once flags to new generated segment, too. */
180 if (!bfd_set_section_flags (stdoutput
, r
, flags
))
181 as_bad (_("bfd_set_section_flags: %s"),
182 bfd_errmsg (bfd_get_error ()));
184 /* Restore to previous segment. */
185 if (save_seg
!= NULL
)
186 subseg_set (save_seg
, save_subseg
);
191 dwcfi_hash_insert (const char *name
, struct dwcfi_seg_list
*item
)
193 const char *error_string
;
195 if ((error_string
= hash_jam (dwcfi_hash
, name
, (char *) item
)))
196 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
200 static struct dwcfi_seg_list
*
201 dwcfi_hash_find (char *name
)
203 return (struct dwcfi_seg_list
*) hash_find (dwcfi_hash
, name
);
206 static struct dwcfi_seg_list
*
207 dwcfi_hash_find_or_make (segT cseg
, const char *base_name
, int flags
)
209 struct dwcfi_seg_list
*item
;
212 /* Initialize dwcfi_hash once. */
214 dwcfi_hash
= hash_new ();
216 name
= get_debugseg_name (cseg
, base_name
);
218 item
= dwcfi_hash_find (name
);
221 item
= alloc_debugseg_item (make_debug_seg (cseg
, name
, flags
), 0, name
);
223 dwcfi_hash_insert (item
->seg_name
, item
);
231 /* ??? Share this with dwarf2cfg.c. */
232 #ifndef TC_DWARF2_EMIT_OFFSET
233 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
235 /* Create an offset to .dwarf2_*. */
238 generic_dwarf2_emit_offset (symbolS
*symbol
, unsigned int size
)
243 exp
.X_add_symbol
= symbol
;
244 exp
.X_add_number
= 0;
245 emit_expr (&exp
, size
);
249 struct cfi_escape_data
251 struct cfi_escape_data
*next
;
257 struct cfi_insn_data
*next
;
283 struct cfi_escape_data
*esc
;
287 unsigned reg
, encoding
;
295 struct fde_entry
*next
;
297 symbolS
*start_address
;
298 symbolS
*end_address
;
299 struct cfi_insn_data
*data
;
300 struct cfi_insn_data
**last
;
301 unsigned char per_encoding
;
302 unsigned char lsda_encoding
;
303 expressionS personality
;
305 unsigned int return_column
;
306 unsigned int signal_frame
;
312 struct cie_entry
*next
;
314 symbolS
*start_address
;
315 unsigned int return_column
;
316 unsigned int signal_frame
;
317 unsigned char per_encoding
;
318 unsigned char lsda_encoding
;
319 expressionS personality
;
320 struct cfi_insn_data
*first
, *last
;
323 /* List of FDE entries. */
325 static struct fde_entry
*all_fde_data
;
326 static struct fde_entry
**last_fde_data
= &all_fde_data
;
328 /* List of CIEs so that they could be reused. */
329 static struct cie_entry
*cie_root
;
331 /* Stack of old CFI data, for save/restore. */
334 struct cfa_save_data
*next
;
338 /* Current open FDE entry. */
341 struct fde_entry
*cur_fde_data
;
342 symbolS
*last_address
;
343 offsetT cur_cfa_offset
;
344 struct cfa_save_data
*cfa_save_stack
;
347 /* Construct a new FDE structure and add it to the end of the fde list. */
349 static struct fde_entry
*
350 alloc_fde_entry (void)
352 struct fde_entry
*fde
= (struct fde_entry
*)
353 xcalloc (1, sizeof (struct fde_entry
));
355 frchain_now
->frch_cfi_data
= (struct frch_cfi_data
*)
356 xcalloc (1, sizeof (struct frch_cfi_data
));
357 frchain_now
->frch_cfi_data
->cur_fde_data
= fde
;
358 *last_fde_data
= fde
;
359 last_fde_data
= &fde
->next
;
360 fde
->cseg
= is_now_linkonce_segment ();
362 fde
->last
= &fde
->data
;
363 fde
->return_column
= DWARF2_DEFAULT_RETURN_COLUMN
;
364 fde
->per_encoding
= DW_EH_PE_omit
;
365 fde
->lsda_encoding
= DW_EH_PE_omit
;
370 /* The following functions are available for a backend to construct its
371 own unwind information, usually from legacy unwind directives. */
373 /* Construct a new INSN structure and add it to the end of the insn list
374 for the currently active FDE. */
376 static struct cfi_insn_data
*
377 alloc_cfi_insn_data (void)
379 struct cfi_insn_data
*insn
= (struct cfi_insn_data
*)
380 xcalloc (1, sizeof (struct cfi_insn_data
));
381 struct fde_entry
*cur_fde_data
= frchain_now
->frch_cfi_data
->cur_fde_data
;
383 *cur_fde_data
->last
= insn
;
384 cur_fde_data
->last
= &insn
->next
;
385 insn
->cur_seg
= is_now_linkonce_segment ();
390 /* Construct a new FDE structure that begins at LABEL. */
393 cfi_new_fde (symbolS
*label
)
395 struct fde_entry
*fde
= alloc_fde_entry ();
396 fde
->start_address
= label
;
397 frchain_now
->frch_cfi_data
->last_address
= label
;
400 /* End the currently open FDE. */
403 cfi_end_fde (symbolS
*label
)
405 frchain_now
->frch_cfi_data
->cur_fde_data
->end_address
= label
;
406 free (frchain_now
->frch_cfi_data
);
407 frchain_now
->frch_cfi_data
= NULL
;
410 /* Set the return column for the current FDE. */
413 cfi_set_return_column (unsigned regno
)
415 frchain_now
->frch_cfi_data
->cur_fde_data
->return_column
= regno
;
418 /* Universal functions to store new instructions. */
421 cfi_add_CFA_insn (int insn
)
423 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
425 insn_ptr
->insn
= insn
;
429 cfi_add_CFA_insn_reg (int insn
, unsigned regno
)
431 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
433 insn_ptr
->insn
= insn
;
434 insn_ptr
->u
.r
= regno
;
438 cfi_add_CFA_insn_offset (int insn
, offsetT offset
)
440 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
442 insn_ptr
->insn
= insn
;
443 insn_ptr
->u
.i
= offset
;
447 cfi_add_CFA_insn_reg_reg (int insn
, unsigned reg1
, unsigned reg2
)
449 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
451 insn_ptr
->insn
= insn
;
452 insn_ptr
->u
.rr
.reg1
= reg1
;
453 insn_ptr
->u
.rr
.reg2
= reg2
;
457 cfi_add_CFA_insn_reg_offset (int insn
, unsigned regno
, offsetT offset
)
459 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
461 insn_ptr
->insn
= insn
;
462 insn_ptr
->u
.ri
.reg
= regno
;
463 insn_ptr
->u
.ri
.offset
= offset
;
466 /* Add a CFI insn to advance the PC from the last address to LABEL. */
469 cfi_add_advance_loc (symbolS
*label
)
471 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
473 insn
->insn
= DW_CFA_advance_loc
;
474 insn
->u
.ll
.lab1
= frchain_now
->frch_cfi_data
->last_address
;
475 insn
->u
.ll
.lab2
= label
;
477 frchain_now
->frch_cfi_data
->last_address
= label
;
480 /* Add a DW_CFA_offset record to the CFI data. */
483 cfi_add_CFA_offset (unsigned regno
, offsetT offset
)
485 unsigned int abs_data_align
;
487 gas_assert (DWARF2_CIE_DATA_ALIGNMENT
!= 0);
488 cfi_add_CFA_insn_reg_offset (DW_CFA_offset
, regno
, offset
);
490 abs_data_align
= (DWARF2_CIE_DATA_ALIGNMENT
< 0
491 ? -DWARF2_CIE_DATA_ALIGNMENT
: DWARF2_CIE_DATA_ALIGNMENT
);
492 if (offset
% abs_data_align
)
493 as_bad (_("register save offset not a multiple of %u"), abs_data_align
);
496 /* Add a DW_CFA_def_cfa record to the CFI data. */
499 cfi_add_CFA_def_cfa (unsigned regno
, offsetT offset
)
501 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa
, regno
, offset
);
502 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
505 /* Add a DW_CFA_register record to the CFI data. */
508 cfi_add_CFA_register (unsigned reg1
, unsigned reg2
)
510 cfi_add_CFA_insn_reg_reg (DW_CFA_register
, reg1
, reg2
);
513 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
516 cfi_add_CFA_def_cfa_register (unsigned regno
)
518 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register
, regno
);
521 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
524 cfi_add_CFA_def_cfa_offset (offsetT offset
)
526 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset
, offset
);
527 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
531 cfi_add_CFA_restore (unsigned regno
)
533 cfi_add_CFA_insn_reg (DW_CFA_restore
, regno
);
537 cfi_add_CFA_undefined (unsigned regno
)
539 cfi_add_CFA_insn_reg (DW_CFA_undefined
, regno
);
543 cfi_add_CFA_same_value (unsigned regno
)
545 cfi_add_CFA_insn_reg (DW_CFA_same_value
, regno
);
549 cfi_add_CFA_remember_state (void)
551 struct cfa_save_data
*p
;
553 cfi_add_CFA_insn (DW_CFA_remember_state
);
555 p
= (struct cfa_save_data
*) xmalloc (sizeof (*p
));
556 p
->cfa_offset
= frchain_now
->frch_cfi_data
->cur_cfa_offset
;
557 p
->next
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
558 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
;
562 cfi_add_CFA_restore_state (void)
564 struct cfa_save_data
*p
;
566 cfi_add_CFA_insn (DW_CFA_restore_state
);
568 p
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
571 frchain_now
->frch_cfi_data
->cur_cfa_offset
= p
->cfa_offset
;
572 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
->next
;
576 as_bad (_("CFI state restore without previous remember"));
580 /* Parse CFI assembler directives. */
582 static void dot_cfi (int);
583 static void dot_cfi_escape (int);
584 static void dot_cfi_sections (int);
585 static void dot_cfi_startproc (int);
586 static void dot_cfi_endproc (int);
587 static void dot_cfi_personality (int);
588 static void dot_cfi_lsda (int);
589 static void dot_cfi_val_encoded_addr (int);
591 /* Fake CFI type; outside the byte range of any real CFI insn. */
592 #define CFI_adjust_cfa_offset 0x100
593 #define CFI_return_column 0x101
594 #define CFI_rel_offset 0x102
595 #define CFI_escape 0x103
596 #define CFI_signal_frame 0x104
597 #define CFI_val_encoded_addr 0x105
599 const pseudo_typeS cfi_pseudo_table
[] =
601 { "cfi_sections", dot_cfi_sections
, 0 },
602 { "cfi_startproc", dot_cfi_startproc
, 0 },
603 { "cfi_endproc", dot_cfi_endproc
, 0 },
604 { "cfi_def_cfa", dot_cfi
, DW_CFA_def_cfa
},
605 { "cfi_def_cfa_register", dot_cfi
, DW_CFA_def_cfa_register
},
606 { "cfi_def_cfa_offset", dot_cfi
, DW_CFA_def_cfa_offset
},
607 { "cfi_adjust_cfa_offset", dot_cfi
, CFI_adjust_cfa_offset
},
608 { "cfi_offset", dot_cfi
, DW_CFA_offset
},
609 { "cfi_rel_offset", dot_cfi
, CFI_rel_offset
},
610 { "cfi_register", dot_cfi
, DW_CFA_register
},
611 { "cfi_return_column", dot_cfi
, CFI_return_column
},
612 { "cfi_restore", dot_cfi
, DW_CFA_restore
},
613 { "cfi_undefined", dot_cfi
, DW_CFA_undefined
},
614 { "cfi_same_value", dot_cfi
, DW_CFA_same_value
},
615 { "cfi_remember_state", dot_cfi
, DW_CFA_remember_state
},
616 { "cfi_restore_state", dot_cfi
, DW_CFA_restore_state
},
617 { "cfi_window_save", dot_cfi
, DW_CFA_GNU_window_save
},
618 { "cfi_escape", dot_cfi_escape
, 0 },
619 { "cfi_signal_frame", dot_cfi
, CFI_signal_frame
},
620 { "cfi_personality", dot_cfi_personality
, 0 },
621 { "cfi_lsda", dot_cfi_lsda
, 0 },
622 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr
, 0 },
627 cfi_parse_separator (void)
630 if (*input_line_pointer
== ',')
631 input_line_pointer
++;
633 as_bad (_("missing separator"));
636 #ifndef tc_parse_to_dw2regnum
638 tc_parse_to_dw2regnum (expressionS
*exp
)
640 # ifdef tc_regname_to_dw2regnum
642 if (is_name_beginner (*input_line_pointer
)
643 || (*input_line_pointer
== '%'
644 && is_name_beginner (*++input_line_pointer
)))
648 name
= input_line_pointer
;
649 c
= get_symbol_end ();
651 exp
->X_op
= O_constant
;
652 exp
->X_add_number
= tc_regname_to_dw2regnum (name
);
654 *input_line_pointer
= c
;
658 expression_and_evaluate (exp
);
668 tc_parse_to_dw2regnum (&exp
);
673 regno
= exp
.X_add_number
;
683 as_bad (_("bad register expression"));
691 cfi_parse_const (void)
693 return get_absolute_expression ();
702 if (frchain_now
->frch_cfi_data
== NULL
)
704 as_bad (_("CFI instruction used without previous .cfi_startproc"));
705 ignore_rest_of_line ();
709 /* If the last address was not at the current PC, advance to current. */
710 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
711 || S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
713 cfi_add_advance_loc (symbol_temp_new_now ());
718 reg1
= cfi_parse_reg ();
719 cfi_parse_separator ();
720 offset
= cfi_parse_const ();
721 cfi_add_CFA_offset (reg1
, offset
);
725 reg1
= cfi_parse_reg ();
726 cfi_parse_separator ();
727 offset
= cfi_parse_const ();
728 cfi_add_CFA_offset (reg1
,
729 offset
- frchain_now
->frch_cfi_data
->cur_cfa_offset
);
733 reg1
= cfi_parse_reg ();
734 cfi_parse_separator ();
735 offset
= cfi_parse_const ();
736 cfi_add_CFA_def_cfa (reg1
, offset
);
739 case DW_CFA_register
:
740 reg1
= cfi_parse_reg ();
741 cfi_parse_separator ();
742 reg2
= cfi_parse_reg ();
743 cfi_add_CFA_register (reg1
, reg2
);
746 case DW_CFA_def_cfa_register
:
747 reg1
= cfi_parse_reg ();
748 cfi_add_CFA_def_cfa_register (reg1
);
751 case DW_CFA_def_cfa_offset
:
752 offset
= cfi_parse_const ();
753 cfi_add_CFA_def_cfa_offset (offset
);
756 case CFI_adjust_cfa_offset
:
757 offset
= cfi_parse_const ();
758 cfi_add_CFA_def_cfa_offset (frchain_now
->frch_cfi_data
->cur_cfa_offset
765 reg1
= cfi_parse_reg ();
766 cfi_add_CFA_restore (reg1
);
768 if (*input_line_pointer
!= ',')
770 ++input_line_pointer
;
774 case DW_CFA_undefined
:
777 reg1
= cfi_parse_reg ();
778 cfi_add_CFA_undefined (reg1
);
780 if (*input_line_pointer
!= ',')
782 ++input_line_pointer
;
786 case DW_CFA_same_value
:
787 reg1
= cfi_parse_reg ();
788 cfi_add_CFA_same_value (reg1
);
791 case CFI_return_column
:
792 reg1
= cfi_parse_reg ();
793 cfi_set_return_column (reg1
);
796 case DW_CFA_remember_state
:
797 cfi_add_CFA_remember_state ();
800 case DW_CFA_restore_state
:
801 cfi_add_CFA_restore_state ();
804 case DW_CFA_GNU_window_save
:
805 cfi_add_CFA_insn (DW_CFA_GNU_window_save
);
808 case CFI_signal_frame
:
809 frchain_now
->frch_cfi_data
->cur_fde_data
->signal_frame
= 1;
816 demand_empty_rest_of_line ();
820 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED
)
822 struct cfi_escape_data
*head
, **tail
, *e
;
823 struct cfi_insn_data
*insn
;
825 if (frchain_now
->frch_cfi_data
== NULL
)
827 as_bad (_("CFI instruction used without previous .cfi_startproc"));
828 ignore_rest_of_line ();
832 /* If the last address was not at the current PC, advance to current. */
833 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
834 || S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
836 cfi_add_advance_loc (symbol_temp_new_now ());
841 e
= (struct cfi_escape_data
*) xmalloc (sizeof (*e
));
842 do_parse_cons_expression (&e
->exp
, 1);
846 while (*input_line_pointer
++ == ',');
849 insn
= alloc_cfi_insn_data ();
850 insn
->insn
= CFI_escape
;
853 --input_line_pointer
;
854 demand_empty_rest_of_line ();
858 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED
)
860 struct fde_entry
*fde
;
863 if (frchain_now
->frch_cfi_data
== NULL
)
865 as_bad (_("CFI instruction used without previous .cfi_startproc"));
866 ignore_rest_of_line ();
870 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
871 encoding
= cfi_parse_const ();
872 if (encoding
== DW_EH_PE_omit
)
874 demand_empty_rest_of_line ();
875 fde
->per_encoding
= encoding
;
879 if ((encoding
& 0xff) != encoding
880 || ((encoding
& 0x70) != 0
881 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
882 && (encoding
& 0x70) != DW_EH_PE_pcrel
885 /* leb128 can be handled, but does something actually need it? */
886 || (encoding
& 7) == DW_EH_PE_uleb128
887 || (encoding
& 7) > DW_EH_PE_udata8
)
889 as_bad (_("invalid or unsupported encoding in .cfi_personality"));
890 ignore_rest_of_line ();
894 if (*input_line_pointer
++ != ',')
896 as_bad (_(".cfi_personality requires encoding and symbol arguments"));
897 ignore_rest_of_line ();
901 expression_and_evaluate (&fde
->personality
);
902 switch (fde
->personality
.X_op
)
907 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
908 encoding
= DW_EH_PE_omit
;
911 encoding
= DW_EH_PE_omit
;
915 fde
->per_encoding
= encoding
;
917 if (encoding
== DW_EH_PE_omit
)
919 as_bad (_("wrong second argument to .cfi_personality"));
920 ignore_rest_of_line ();
924 demand_empty_rest_of_line ();
928 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED
)
930 struct fde_entry
*fde
;
933 if (frchain_now
->frch_cfi_data
== NULL
)
935 as_bad (_("CFI instruction used without previous .cfi_startproc"));
936 ignore_rest_of_line ();
940 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
941 encoding
= cfi_parse_const ();
942 if (encoding
== DW_EH_PE_omit
)
944 demand_empty_rest_of_line ();
945 fde
->lsda_encoding
= encoding
;
949 if ((encoding
& 0xff) != encoding
950 || ((encoding
& 0x70) != 0
951 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
952 && (encoding
& 0x70) != DW_EH_PE_pcrel
955 /* leb128 can be handled, but does something actually need it? */
956 || (encoding
& 7) == DW_EH_PE_uleb128
957 || (encoding
& 7) > DW_EH_PE_udata8
)
959 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
960 ignore_rest_of_line ();
964 if (*input_line_pointer
++ != ',')
966 as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
967 ignore_rest_of_line ();
971 fde
->lsda_encoding
= encoding
;
973 expression_and_evaluate (&fde
->lsda
);
974 switch (fde
->lsda
.X_op
)
979 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
980 encoding
= DW_EH_PE_omit
;
983 encoding
= DW_EH_PE_omit
;
987 fde
->lsda_encoding
= encoding
;
989 if (encoding
== DW_EH_PE_omit
)
991 as_bad (_("wrong second argument to .cfi_lsda"));
992 ignore_rest_of_line ();
996 demand_empty_rest_of_line ();
1000 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED
)
1002 struct cfi_insn_data
*insn_ptr
;
1005 if (frchain_now
->frch_cfi_data
== NULL
)
1007 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1008 ignore_rest_of_line ();
1012 /* If the last address was not at the current PC, advance to current. */
1013 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
1014 || S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
1016 cfi_add_advance_loc (symbol_temp_new_now ());
1018 insn_ptr
= alloc_cfi_insn_data ();
1019 insn_ptr
->insn
= CFI_val_encoded_addr
;
1021 insn_ptr
->u
.ea
.reg
= cfi_parse_reg ();
1023 cfi_parse_separator ();
1024 encoding
= cfi_parse_const ();
1025 if ((encoding
& 0xff) != encoding
1026 || ((encoding
& 0x70) != 0
1027 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1028 && (encoding
& 0x70) != DW_EH_PE_pcrel
1031 /* leb128 can be handled, but does something actually need it? */
1032 || (encoding
& 7) == DW_EH_PE_uleb128
1033 || (encoding
& 7) > DW_EH_PE_udata8
)
1035 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1036 encoding
= DW_EH_PE_omit
;
1039 cfi_parse_separator ();
1040 expression_and_evaluate (&insn_ptr
->u
.ea
.exp
);
1041 switch (insn_ptr
->u
.ea
.exp
.X_op
)
1046 if ((encoding
& 0x70) != DW_EH_PE_pcrel
)
1049 encoding
= DW_EH_PE_omit
;
1053 insn_ptr
->u
.ea
.encoding
= encoding
;
1054 if (encoding
== DW_EH_PE_omit
)
1056 as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1057 ignore_rest_of_line ();
1061 demand_empty_rest_of_line ();
1064 /* By default emit .eh_frame only, not .debug_frame. */
1065 #define CFI_EMIT_eh_frame (1 << 0)
1066 #define CFI_EMIT_debug_frame (1 << 1)
1067 static int cfi_sections
= CFI_EMIT_eh_frame
;
1070 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED
)
1075 if (is_name_beginner (*input_line_pointer
))
1080 name
= input_line_pointer
;
1081 c
= get_symbol_end ();
1083 if (strncmp (name
, ".eh_frame", sizeof ".eh_frame") == 0
1085 sections
|= CFI_EMIT_eh_frame
;
1086 else if (strncmp (name
, ".debug_frame", sizeof ".debug_frame") == 0)
1087 sections
|= CFI_EMIT_debug_frame
;
1090 *input_line_pointer
= c
;
1091 input_line_pointer
= name
;
1095 *input_line_pointer
= c
;
1097 if (*input_line_pointer
== ',')
1099 name
= input_line_pointer
++;
1101 if (!is_name_beginner (*input_line_pointer
))
1103 input_line_pointer
= name
;
1107 else if (is_name_beginner (*input_line_pointer
))
1111 demand_empty_rest_of_line ();
1112 cfi_sections
= sections
;
1116 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED
)
1120 if (frchain_now
->frch_cfi_data
!= NULL
)
1122 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1123 ignore_rest_of_line ();
1127 cfi_new_fde (symbol_temp_new_now ());
1130 if (is_name_beginner (*input_line_pointer
))
1134 name
= input_line_pointer
;
1135 c
= get_symbol_end ();
1137 if (strcmp (name
, "simple") == 0)
1140 *input_line_pointer
= c
;
1143 input_line_pointer
= name
;
1145 demand_empty_rest_of_line ();
1147 frchain_now
->frch_cfi_data
->cur_cfa_offset
= 0;
1149 tc_cfi_frame_initial_instructions ();
1153 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED
)
1155 if (frchain_now
->frch_cfi_data
== NULL
)
1157 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1158 ignore_rest_of_line ();
1162 cfi_end_fde (symbol_temp_new_now ());
1164 demand_empty_rest_of_line ();
1168 /* Emit a single byte into the current segment. */
1173 FRAG_APPEND_1_CHAR (byte
);
1176 /* Emit a two-byte word into the current segment. */
1181 md_number_to_chars (frag_more (2), data
, 2);
1184 /* Emit a four byte word into the current segment. */
1189 md_number_to_chars (frag_more (4), data
, 4);
1192 /* Emit an unsigned "little-endian base 128" number. */
1195 out_uleb128 (addressT value
)
1197 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1200 /* Emit an unsigned "little-endian base 128" number. */
1203 out_sleb128 (offsetT value
)
1205 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1209 output_cfi_insn (struct cfi_insn_data
*insn
)
1216 case DW_CFA_advance_loc
:
1218 symbolS
*from
= insn
->u
.ll
.lab1
;
1219 symbolS
*to
= insn
->u
.ll
.lab2
;
1221 if (symbol_get_frag (to
) == symbol_get_frag (from
))
1223 addressT delta
= S_GET_VALUE (to
) - S_GET_VALUE (from
);
1224 addressT scaled
= delta
/ DWARF2_LINE_MIN_INSN_LENGTH
;
1227 out_one (DW_CFA_advance_loc
+ scaled
);
1228 else if (scaled
<= 0xFF)
1230 out_one (DW_CFA_advance_loc1
);
1233 else if (scaled
<= 0xFFFF)
1235 out_one (DW_CFA_advance_loc2
);
1240 out_one (DW_CFA_advance_loc4
);
1248 exp
.X_op
= O_subtract
;
1249 exp
.X_add_symbol
= to
;
1250 exp
.X_op_symbol
= from
;
1251 exp
.X_add_number
= 0;
1253 /* The code in ehopt.c expects that one byte of the encoding
1254 is already allocated to the frag. This comes from the way
1255 that it scans the .eh_frame section looking first for the
1256 .byte DW_CFA_advance_loc4. */
1257 *frag_more (1) = DW_CFA_advance_loc4
;
1259 frag_var (rs_cfa
, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH
<< 3,
1260 make_expr_symbol (&exp
), frag_now_fix () - 1,
1266 case DW_CFA_def_cfa
:
1267 offset
= insn
->u
.ri
.offset
;
1270 out_one (DW_CFA_def_cfa_sf
);
1271 out_uleb128 (insn
->u
.ri
.reg
);
1272 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1276 out_one (DW_CFA_def_cfa
);
1277 out_uleb128 (insn
->u
.ri
.reg
);
1278 out_uleb128 (offset
);
1282 case DW_CFA_def_cfa_register
:
1283 case DW_CFA_undefined
:
1284 case DW_CFA_same_value
:
1285 out_one (insn
->insn
);
1286 out_uleb128 (insn
->u
.r
);
1289 case DW_CFA_def_cfa_offset
:
1293 out_one (DW_CFA_def_cfa_offset_sf
);
1294 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1298 out_one (DW_CFA_def_cfa_offset
);
1299 out_uleb128 (offset
);
1303 case DW_CFA_restore
:
1307 out_one (DW_CFA_restore
+ regno
);
1311 out_one (DW_CFA_restore_extended
);
1312 out_uleb128 (regno
);
1317 regno
= insn
->u
.ri
.reg
;
1318 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
1321 out_one (DW_CFA_offset_extended_sf
);
1322 out_uleb128 (regno
);
1323 out_sleb128 (offset
);
1325 else if (regno
<= 0x3F)
1327 out_one (DW_CFA_offset
+ regno
);
1328 out_uleb128 (offset
);
1332 out_one (DW_CFA_offset_extended
);
1333 out_uleb128 (regno
);
1334 out_uleb128 (offset
);
1338 case DW_CFA_register
:
1339 out_one (DW_CFA_register
);
1340 out_uleb128 (insn
->u
.rr
.reg1
);
1341 out_uleb128 (insn
->u
.rr
.reg2
);
1344 case DW_CFA_remember_state
:
1345 case DW_CFA_restore_state
:
1346 out_one (insn
->insn
);
1349 case DW_CFA_GNU_window_save
:
1350 out_one (DW_CFA_GNU_window_save
);
1355 struct cfi_escape_data
*e
;
1356 for (e
= insn
->u
.esc
; e
; e
= e
->next
)
1357 emit_expr (&e
->exp
, 1);
1361 case CFI_val_encoded_addr
:
1363 unsigned encoding
= insn
->u
.ea
.encoding
;
1364 offsetT encoding_size
;
1366 if (encoding
== DW_EH_PE_omit
)
1368 out_one (DW_CFA_val_expression
);
1369 out_uleb128 (insn
->u
.ea
.reg
);
1371 switch (encoding
& 0x7)
1373 case DW_EH_PE_absptr
:
1374 encoding_size
= DWARF2_ADDR_SIZE (stdoutput
);
1376 case DW_EH_PE_udata2
:
1379 case DW_EH_PE_udata4
:
1382 case DW_EH_PE_udata8
:
1389 /* If the user has requested absolute encoding,
1390 then use the smaller DW_OP_addr encoding. */
1391 if (insn
->u
.ea
.encoding
== DW_EH_PE_absptr
)
1393 out_uleb128 (1 + encoding_size
);
1394 out_one (DW_OP_addr
);
1398 out_uleb128 (1 + 1 + encoding_size
);
1399 out_one (DW_OP_GNU_encoded_addr
);
1402 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1404 #if CFI_DIFF_EXPR_OK
1405 insn
->u
.ea
.exp
.X_op
= O_subtract
;
1406 insn
->u
.ea
.exp
.X_op_symbol
= symbol_temp_new_now ();
1407 #elif defined (tc_cfi_emit_pcrel_expr)
1408 tc_cfi_emit_pcrel_expr (&insn
->u
.ea
.exp
, encoding_size
);
1415 emit_expr (&insn
->u
.ea
.exp
, encoding_size
);
1425 encoding_size (unsigned char encoding
)
1427 if (encoding
== DW_EH_PE_omit
)
1429 switch (encoding
& 0x7)
1432 return bfd_get_arch_size (stdoutput
) == 64 ? 8 : 4;
1433 case DW_EH_PE_udata2
:
1435 case DW_EH_PE_udata4
:
1437 case DW_EH_PE_udata8
:
1445 output_cie (struct cie_entry
*cie
, bfd_boolean eh_frame
, int align
)
1447 symbolS
*after_size_address
, *end_address
;
1449 struct cfi_insn_data
*i
;
1450 offsetT augmentation_size
;
1452 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1454 cie
->start_address
= symbol_temp_new_now ();
1455 after_size_address
= symbol_temp_make ();
1456 end_address
= symbol_temp_make ();
1458 exp
.X_op
= O_subtract
;
1459 exp
.X_add_symbol
= end_address
;
1460 exp
.X_op_symbol
= after_size_address
;
1461 exp
.X_add_number
= 0;
1463 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1464 emit_expr (&exp
, 4); /* Length. */
1467 if (fmt
== dwarf2_format_64bit
)
1469 emit_expr (&exp
, 8); /* Length. */
1471 symbol_set_value_now (after_size_address
);
1473 out_four (0); /* CIE id. */
1476 out_four (-1); /* CIE id. */
1477 if (fmt
!= dwarf2_format_32bit
)
1480 out_one (DW_CIE_VERSION
); /* Version. */
1483 out_one ('z'); /* Augmentation. */
1484 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1486 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1490 if (cie
->signal_frame
)
1493 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH
); /* Code alignment. */
1494 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT
); /* Data alignment. */
1495 if (DW_CIE_VERSION
== 1) /* Return column. */
1496 out_one (cie
->return_column
);
1498 out_uleb128 (cie
->return_column
);
1501 augmentation_size
= 1 + (cie
->lsda_encoding
!= DW_EH_PE_omit
);
1502 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1503 augmentation_size
+= 1 + encoding_size (cie
->per_encoding
);
1504 out_uleb128 (augmentation_size
); /* Augmentation size. */
1506 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1508 offsetT size
= encoding_size (cie
->per_encoding
);
1509 out_one (cie
->per_encoding
);
1510 exp
= cie
->personality
;
1511 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1513 #if CFI_DIFF_EXPR_OK
1514 exp
.X_op
= O_subtract
;
1515 exp
.X_op_symbol
= symbol_temp_new_now ();
1516 emit_expr (&exp
, size
);
1517 #elif defined (tc_cfi_emit_pcrel_expr)
1518 tc_cfi_emit_pcrel_expr (&exp
, size
);
1524 emit_expr (&exp
, size
);
1527 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1528 out_one (cie
->lsda_encoding
);
1531 switch (DWARF2_FDE_RELOC_SIZE
)
1534 enc
= DW_EH_PE_sdata2
;
1537 enc
= DW_EH_PE_sdata4
;
1540 enc
= DW_EH_PE_sdata8
;
1545 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1546 enc
|= DW_EH_PE_pcrel
;
1553 for (i
= cie
->first
; i
!= cie
->last
; i
= i
->next
)
1555 if (i
->cur_seg
!= cie
->cur_seg
)
1557 output_cfi_insn (i
);
1561 frag_align (align
, DW_CFA_nop
, 0);
1562 symbol_set_value_now (end_address
);
1566 output_fde (struct fde_entry
*fde
, struct cie_entry
*cie
,
1567 bfd_boolean eh_frame
, struct cfi_insn_data
*first
,
1570 symbolS
*after_size_address
, *end_address
;
1572 offsetT augmentation_size
;
1573 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1577 after_size_address
= symbol_temp_make ();
1578 end_address
= symbol_temp_make ();
1580 exp
.X_op
= O_subtract
;
1581 exp
.X_add_symbol
= end_address
;
1582 exp
.X_op_symbol
= after_size_address
;
1583 exp
.X_add_number
= 0;
1584 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1588 if (fmt
== dwarf2_format_64bit
)
1592 emit_expr (&exp
, offset_size
); /* Length. */
1593 symbol_set_value_now (after_size_address
);
1597 exp
.X_op
= O_subtract
;
1598 exp
.X_add_symbol
= after_size_address
;
1599 exp
.X_op_symbol
= cie
->start_address
;
1600 exp
.X_add_number
= 0;
1601 emit_expr (&exp
, offset_size
); /* CIE offset. */
1605 TC_DWARF2_EMIT_OFFSET (cie
->start_address
, offset_size
);
1610 exp
.X_op
= O_subtract
;
1611 exp
.X_add_number
= 0;
1612 #if CFI_DIFF_EXPR_OK
1613 exp
.X_add_symbol
= fde
->start_address
;
1614 exp
.X_op_symbol
= symbol_temp_new_now ();
1615 emit_expr (&exp
, DWARF2_FDE_RELOC_SIZE
); /* Code offset. */
1617 exp
.X_op
= O_symbol
;
1618 exp
.X_add_symbol
= fde
->start_address
;
1619 #ifdef tc_cfi_emit_pcrel_expr
1620 tc_cfi_emit_pcrel_expr (&exp
, DWARF2_FDE_RELOC_SIZE
); /* Code offset. */
1622 emit_expr (&exp
, DWARF2_FDE_RELOC_SIZE
); /* Code offset. */
1625 addr_size
= DWARF2_FDE_RELOC_SIZE
;
1629 exp
.X_op
= O_symbol
;
1630 exp
.X_add_symbol
= fde
->start_address
;
1631 exp
.X_add_number
= 0;
1632 addr_size
= DWARF2_ADDR_SIZE (stdoutput
);
1633 emit_expr (&exp
, addr_size
);
1636 exp
.X_op
= O_subtract
;
1637 exp
.X_add_symbol
= fde
->end_address
;
1638 exp
.X_op_symbol
= fde
->start_address
; /* Code length. */
1639 exp
.X_add_number
= 0;
1640 emit_expr (&exp
, addr_size
);
1642 augmentation_size
= encoding_size (fde
->lsda_encoding
);
1644 out_uleb128 (augmentation_size
); /* Augmentation size. */
1646 if (fde
->lsda_encoding
!= DW_EH_PE_omit
)
1649 if ((fde
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1651 #if CFI_DIFF_LSDA_OK
1652 exp
.X_op
= O_subtract
;
1653 exp
.X_op_symbol
= symbol_temp_new_now ();
1654 emit_expr (&exp
, augmentation_size
);
1655 #elif defined (tc_cfi_emit_pcrel_expr)
1656 tc_cfi_emit_pcrel_expr (&exp
, augmentation_size
);
1662 emit_expr (&exp
, augmentation_size
);
1665 for (; first
; first
= first
->next
)
1667 if (first
->cur_seg
== fde
->cseg
)
1668 output_cfi_insn (first
);
1671 frag_align (align
, DW_CFA_nop
, 0);
1672 symbol_set_value_now (end_address
);
1675 static struct cie_entry
*
1676 select_cie_for_fde (struct fde_entry
*fde
, bfd_boolean eh_frame
,
1677 struct cfi_insn_data
**pfirst
, int align
)
1679 struct cfi_insn_data
*i
, *j
;
1680 struct cie_entry
*cie
;
1682 for (cie
= cie_root
; cie
; cie
= cie
->next
)
1684 if (cie
->cur_seg
!= fde
->cseg
1685 || cie
->return_column
!= fde
->return_column
1686 || cie
->signal_frame
!= fde
->signal_frame
1687 || cie
->per_encoding
!= fde
->per_encoding
1688 || cie
->lsda_encoding
!= fde
->lsda_encoding
)
1690 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1692 if (cie
->personality
.X_op
!= fde
->personality
.X_op
1693 || cie
->personality
.X_add_number
1694 != fde
->personality
.X_add_number
)
1696 switch (cie
->personality
.X_op
)
1699 if (cie
->personality
.X_unsigned
!= fde
->personality
.X_unsigned
)
1703 if (cie
->personality
.X_add_symbol
1704 != fde
->personality
.X_add_symbol
)
1711 for (i
= cie
->first
, j
= fde
->data
;
1712 i
!= cie
->last
&& j
!= NULL
;
1713 i
= i
->next
, j
= j
->next
)
1715 if (i
->insn
!= j
->insn
)
1719 case DW_CFA_advance_loc
:
1720 case DW_CFA_remember_state
:
1721 /* We reached the first advance/remember in the FDE,
1722 but did not reach the end of the CIE list. */
1726 case DW_CFA_def_cfa
:
1727 if (i
->u
.ri
.reg
!= j
->u
.ri
.reg
)
1729 if (i
->u
.ri
.offset
!= j
->u
.ri
.offset
)
1733 case DW_CFA_register
:
1734 if (i
->u
.rr
.reg1
!= j
->u
.rr
.reg1
)
1736 if (i
->u
.rr
.reg2
!= j
->u
.rr
.reg2
)
1740 case DW_CFA_def_cfa_register
:
1741 case DW_CFA_restore
:
1742 case DW_CFA_undefined
:
1743 case DW_CFA_same_value
:
1744 if (i
->u
.r
!= j
->u
.r
)
1748 case DW_CFA_def_cfa_offset
:
1749 if (i
->u
.i
!= j
->u
.i
)
1754 case CFI_val_encoded_addr
:
1755 /* Don't bother matching these for now. */
1763 /* Success if we reached the end of the CIE list, and we've either
1764 run out of FDE entries or we've encountered an advance,
1765 remember, or escape. */
1768 || j
->insn
== DW_CFA_advance_loc
1769 || j
->insn
== DW_CFA_remember_state
1770 || j
->insn
== CFI_escape
1771 || j
->insn
== CFI_val_encoded_addr
))
1780 cie
= (struct cie_entry
*) xmalloc (sizeof (struct cie_entry
));
1781 cie
->next
= cie_root
;
1783 cie
->cur_seg
= fde
->cseg
;
1784 cie
->return_column
= fde
->return_column
;
1785 cie
->signal_frame
= fde
->signal_frame
;
1786 cie
->per_encoding
= fde
->per_encoding
;
1787 cie
->lsda_encoding
= fde
->lsda_encoding
;
1788 cie
->personality
= fde
->personality
;
1789 cie
->first
= fde
->data
;
1791 for (i
= cie
->first
; i
; i
= i
->next
)
1792 if (i
->insn
== DW_CFA_advance_loc
1793 || i
->insn
== DW_CFA_remember_state
1794 || i
->insn
== CFI_escape
1795 || i
->insn
== CFI_val_encoded_addr
)
1801 output_cie (cie
, eh_frame
, align
);
1806 #ifdef md_reg_eh_frame_to_debug_frame
1808 cfi_change_reg_numbers (struct cfi_insn_data
*insn
, segT ccseg
)
1810 for (; insn
; insn
= insn
->next
)
1812 if (insn
->cur_seg
!= ccseg
)
1816 case DW_CFA_advance_loc
:
1817 case DW_CFA_def_cfa_offset
:
1818 case DW_CFA_remember_state
:
1819 case DW_CFA_restore_state
:
1820 case DW_CFA_GNU_window_save
:
1824 case DW_CFA_def_cfa
:
1826 insn
->u
.ri
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ri
.reg
);
1829 case DW_CFA_def_cfa_register
:
1830 case DW_CFA_undefined
:
1831 case DW_CFA_same_value
:
1832 case DW_CFA_restore
:
1833 insn
->u
.r
= md_reg_eh_frame_to_debug_frame (insn
->u
.r
);
1836 case DW_CFA_register
:
1837 insn
->u
.rr
.reg1
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg1
);
1838 insn
->u
.rr
.reg2
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg2
);
1841 case CFI_val_encoded_addr
:
1842 insn
->u
.ea
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ea
.reg
);
1851 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
1855 get_cfi_seg (segT cseg
, const char *base
, flagword flags
, int align
)
1857 struct dwcfi_seg_list
*l
;
1859 l
= dwcfi_hash_find_or_make (cseg
, base
, flags
);
1861 subseg_set (l
->seg
, l
->subseg
);
1862 record_alignment (l
->seg
, align
);
1869 struct cie_entry
*cie
, *cie_next
;
1870 segT cfi_seg
, ccseg
;
1871 struct fde_entry
*fde
;
1872 struct cfi_insn_data
*first
;
1873 int save_flag_traditional_format
, seek_next_seg
;
1875 if (all_fde_data
== 0)
1878 if ((cfi_sections
& CFI_EMIT_eh_frame
) != 0)
1880 /* Make sure check_eh_frame doesn't do anything with our output. */
1881 save_flag_traditional_format
= flag_traditional_format
;
1882 flag_traditional_format
= 1;
1889 for (cie
= cie_root
; cie
; cie
= cie_next
)
1891 cie_next
= cie
->next
;
1892 free ((void *) cie
);
1896 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1898 if (fde
->handled
!= 0)
1900 if (seek_next_seg
&& fde
->cseg
!= ccseg
)
1908 /* Open .eh_frame section. */
1909 cfi_seg
= get_cfi_seg (ccseg
, ".eh_frame",
1910 SEC_ALLOC
| SEC_LOAD
| SEC_DATA
1911 | DWARF2_EH_FRAME_READ_ONLY
,
1912 EH_FRAME_ALIGNMENT
);
1913 #ifdef md_fix_up_eh_frame
1914 md_fix_up_eh_frame (cfi_seg
);
1920 if (fde
->end_address
== NULL
)
1922 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1923 fde
->end_address
= fde
->start_address
;
1926 cie
= select_cie_for_fde (fde
, TRUE
, &first
, 2);
1927 output_fde (fde
, cie
, TRUE
, first
,
1928 fde
->next
== NULL
? EH_FRAME_ALIGNMENT
: 2);
1931 while (seek_next_seg
== 2);
1933 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1936 flag_traditional_format
= save_flag_traditional_format
;
1939 if ((cfi_sections
& CFI_EMIT_debug_frame
) != 0)
1941 int alignment
= ffs (DWARF2_ADDR_SIZE (stdoutput
)) - 1;
1948 for (cie
= cie_root
; cie
; cie
= cie_next
)
1950 cie_next
= cie
->next
;
1951 free ((void *) cie
);
1955 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1957 if (fde
->handled
!= 0)
1959 if (seek_next_seg
&& fde
->cseg
!= ccseg
)
1967 /* Open .debug_frame section. */
1968 cfi_seg
= get_cfi_seg (ccseg
, ".debug_frame",
1969 SEC_READONLY
| SEC_DEBUGGING
,
1974 if (fde
->end_address
== NULL
)
1976 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1977 fde
->end_address
= fde
->start_address
;
1980 fde
->per_encoding
= DW_EH_PE_omit
;
1981 fde
->lsda_encoding
= DW_EH_PE_omit
;
1982 cfi_change_reg_numbers (fde
->data
, ccseg
);
1983 cie
= select_cie_for_fde (fde
, FALSE
, &first
, alignment
);
1984 output_fde (fde
, cie
, FALSE
, first
, alignment
);
1987 while (seek_next_seg
== 2);
1989 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1994 #else /* TARGET_USE_CFIPOP */
1996 /* Emit an intelligible error message for missing support. */
1999 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED
)
2001 as_bad (_("CFI is not supported for this target"));
2002 ignore_rest_of_line ();
2005 const pseudo_typeS cfi_pseudo_table
[] =
2007 { "cfi_sections", dot_cfi_dummy
, 0 },
2008 { "cfi_startproc", dot_cfi_dummy
, 0 },
2009 { "cfi_endproc", dot_cfi_dummy
, 0 },
2010 { "cfi_def_cfa", dot_cfi_dummy
, 0 },
2011 { "cfi_def_cfa_register", dot_cfi_dummy
, 0 },
2012 { "cfi_def_cfa_offset", dot_cfi_dummy
, 0 },
2013 { "cfi_adjust_cfa_offset", dot_cfi_dummy
, 0 },
2014 { "cfi_offset", dot_cfi_dummy
, 0 },
2015 { "cfi_rel_offset", dot_cfi_dummy
, 0 },
2016 { "cfi_register", dot_cfi_dummy
, 0 },
2017 { "cfi_return_column", dot_cfi_dummy
, 0 },
2018 { "cfi_restore", dot_cfi_dummy
, 0 },
2019 { "cfi_undefined", dot_cfi_dummy
, 0 },
2020 { "cfi_same_value", dot_cfi_dummy
, 0 },
2021 { "cfi_remember_state", dot_cfi_dummy
, 0 },
2022 { "cfi_restore_state", dot_cfi_dummy
, 0 },
2023 { "cfi_window_save", dot_cfi_dummy
, 0 },
2024 { "cfi_escape", dot_cfi_dummy
, 0 },
2025 { "cfi_signal_frame", dot_cfi_dummy
, 0 },
2026 { "cfi_personality", dot_cfi_dummy
, 0 },
2027 { "cfi_lsda", dot_cfi_dummy
, 0 },
2028 { "cfi_val_encoded_addr", dot_cfi_dummy
, 0 },
2036 #endif /* TARGET_USE_CFIPOP */