1 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
2 Copyright 2003, 2004, 2005, 2006, 2007, 2008, 2009
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 /* We re-use DWARF2_LINE_MIN_INSN_LENGTH for the code alignment field
40 of the CIE. Default to 1 if not otherwise specified. */
41 #ifndef DWARF2_LINE_MIN_INSN_LENGTH
42 # define DWARF2_LINE_MIN_INSN_LENGTH 1
45 /* By default, use 32-bit relocations from .eh_frame into .text. */
46 #ifndef DWARF2_FDE_RELOC_SIZE
47 # define DWARF2_FDE_RELOC_SIZE 4
50 /* By default, use a read-only .eh_frame section. */
51 #ifndef DWARF2_EH_FRAME_READ_ONLY
52 # define DWARF2_EH_FRAME_READ_ONLY SEC_READONLY
55 #ifndef EH_FRAME_ALIGNMENT
56 # define EH_FRAME_ALIGNMENT (bfd_get_arch_size (stdoutput) == 64 ? 3 : 2)
59 #ifndef tc_cfi_frame_initial_instructions
60 # define tc_cfi_frame_initial_instructions() ((void)0)
64 # define DWARF2_FORMAT(SEC) dwarf2_format_32bit
67 #ifndef DWARF2_ADDR_SIZE
68 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
71 struct cfi_escape_data
{
72 struct cfi_escape_data
*next
;
78 struct cfi_insn_data
*next
;
99 struct cfi_escape_data
*esc
;
102 unsigned reg
, encoding
;
110 struct fde_entry
*next
;
111 symbolS
*start_address
;
112 symbolS
*end_address
;
113 struct cfi_insn_data
*data
;
114 struct cfi_insn_data
**last
;
115 unsigned char per_encoding
;
116 unsigned char lsda_encoding
;
117 expressionS personality
;
119 unsigned int return_column
;
120 unsigned int signal_frame
;
125 struct cie_entry
*next
;
126 symbolS
*start_address
;
127 unsigned int return_column
;
128 unsigned int signal_frame
;
129 unsigned char per_encoding
;
130 unsigned char lsda_encoding
;
131 expressionS personality
;
132 struct cfi_insn_data
*first
, *last
;
136 /* List of FDE entries. */
137 static struct fde_entry
*all_fde_data
;
138 static struct fde_entry
**last_fde_data
= &all_fde_data
;
140 /* List of CIEs so that they could be reused. */
141 static struct cie_entry
*cie_root
;
143 /* Stack of old CFI data, for save/restore. */
146 struct cfa_save_data
*next
;
150 /* Current open FDE entry. */
153 struct fde_entry
*cur_fde_data
;
154 symbolS
*last_address
;
155 offsetT cur_cfa_offset
;
156 struct cfa_save_data
*cfa_save_stack
;
159 /* Construct a new FDE structure and add it to the end of the fde list. */
161 static struct fde_entry
*
162 alloc_fde_entry (void)
164 struct fde_entry
*fde
= (struct fde_entry
*)
165 xcalloc (1, sizeof (struct fde_entry
));
167 frchain_now
->frch_cfi_data
= (struct frch_cfi_data
*)
168 xcalloc (1, sizeof (struct frch_cfi_data
));
169 frchain_now
->frch_cfi_data
->cur_fde_data
= fde
;
170 *last_fde_data
= fde
;
171 last_fde_data
= &fde
->next
;
173 fde
->last
= &fde
->data
;
174 fde
->return_column
= DWARF2_DEFAULT_RETURN_COLUMN
;
175 fde
->per_encoding
= DW_EH_PE_omit
;
176 fde
->lsda_encoding
= DW_EH_PE_omit
;
181 /* The following functions are available for a backend to construct its
182 own unwind information, usually from legacy unwind directives. */
184 /* Construct a new INSN structure and add it to the end of the insn list
185 for the currently active FDE. */
187 static struct cfi_insn_data
*
188 alloc_cfi_insn_data (void)
190 struct cfi_insn_data
*insn
= (struct cfi_insn_data
*)
191 xcalloc (1, sizeof (struct cfi_insn_data
));
192 struct fde_entry
*cur_fde_data
= frchain_now
->frch_cfi_data
->cur_fde_data
;
194 *cur_fde_data
->last
= insn
;
195 cur_fde_data
->last
= &insn
->next
;
200 /* Construct a new FDE structure that begins at LABEL. */
203 cfi_new_fde (symbolS
*label
)
205 struct fde_entry
*fde
= alloc_fde_entry ();
206 fde
->start_address
= label
;
207 frchain_now
->frch_cfi_data
->last_address
= label
;
210 /* End the currently open FDE. */
213 cfi_end_fde (symbolS
*label
)
215 frchain_now
->frch_cfi_data
->cur_fde_data
->end_address
= label
;
216 free (frchain_now
->frch_cfi_data
);
217 frchain_now
->frch_cfi_data
= NULL
;
220 /* Set the return column for the current FDE. */
223 cfi_set_return_column (unsigned regno
)
225 frchain_now
->frch_cfi_data
->cur_fde_data
->return_column
= regno
;
228 /* Universal functions to store new instructions. */
231 cfi_add_CFA_insn(int insn
)
233 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
235 insn_ptr
->insn
= insn
;
239 cfi_add_CFA_insn_reg (int insn
, unsigned regno
)
241 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
243 insn_ptr
->insn
= insn
;
244 insn_ptr
->u
.r
= regno
;
248 cfi_add_CFA_insn_offset (int insn
, offsetT offset
)
250 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
252 insn_ptr
->insn
= insn
;
253 insn_ptr
->u
.i
= offset
;
257 cfi_add_CFA_insn_reg_reg (int insn
, unsigned reg1
, unsigned reg2
)
259 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
261 insn_ptr
->insn
= insn
;
262 insn_ptr
->u
.rr
.reg1
= reg1
;
263 insn_ptr
->u
.rr
.reg2
= reg2
;
267 cfi_add_CFA_insn_reg_offset (int insn
, unsigned regno
, offsetT offset
)
269 struct cfi_insn_data
*insn_ptr
= alloc_cfi_insn_data ();
271 insn_ptr
->insn
= insn
;
272 insn_ptr
->u
.ri
.reg
= regno
;
273 insn_ptr
->u
.ri
.offset
= offset
;
276 /* Add a CFI insn to advance the PC from the last address to LABEL. */
279 cfi_add_advance_loc (symbolS
*label
)
281 struct cfi_insn_data
*insn
= alloc_cfi_insn_data ();
283 insn
->insn
= DW_CFA_advance_loc
;
284 insn
->u
.ll
.lab1
= frchain_now
->frch_cfi_data
->last_address
;
285 insn
->u
.ll
.lab2
= label
;
287 frchain_now
->frch_cfi_data
->last_address
= label
;
290 /* Add a DW_CFA_offset record to the CFI data. */
293 cfi_add_CFA_offset (unsigned regno
, offsetT offset
)
295 unsigned int abs_data_align
;
297 gas_assert (DWARF2_CIE_DATA_ALIGNMENT
!= 0);
298 cfi_add_CFA_insn_reg_offset (DW_CFA_offset
, regno
, offset
);
300 abs_data_align
= (DWARF2_CIE_DATA_ALIGNMENT
< 0
301 ? -DWARF2_CIE_DATA_ALIGNMENT
: DWARF2_CIE_DATA_ALIGNMENT
);
302 if (offset
% abs_data_align
)
303 as_bad (_("register save offset not a multiple of %u"), abs_data_align
);
306 /* Add a DW_CFA_def_cfa record to the CFI data. */
309 cfi_add_CFA_def_cfa (unsigned regno
, offsetT offset
)
311 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa
, regno
, offset
);
312 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
315 /* Add a DW_CFA_register record to the CFI data. */
318 cfi_add_CFA_register (unsigned reg1
, unsigned reg2
)
320 cfi_add_CFA_insn_reg_reg (DW_CFA_register
, reg1
, reg2
);
323 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
326 cfi_add_CFA_def_cfa_register (unsigned regno
)
328 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register
, regno
);
331 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
334 cfi_add_CFA_def_cfa_offset (offsetT offset
)
336 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset
, offset
);
337 frchain_now
->frch_cfi_data
->cur_cfa_offset
= offset
;
341 cfi_add_CFA_restore (unsigned regno
)
343 cfi_add_CFA_insn_reg (DW_CFA_restore
, regno
);
347 cfi_add_CFA_undefined (unsigned regno
)
349 cfi_add_CFA_insn_reg (DW_CFA_undefined
, regno
);
353 cfi_add_CFA_same_value (unsigned regno
)
355 cfi_add_CFA_insn_reg (DW_CFA_same_value
, regno
);
359 cfi_add_CFA_remember_state (void)
361 struct cfa_save_data
*p
;
363 cfi_add_CFA_insn (DW_CFA_remember_state
);
365 p
= (struct cfa_save_data
*) xmalloc (sizeof (*p
));
366 p
->cfa_offset
= frchain_now
->frch_cfi_data
->cur_cfa_offset
;
367 p
->next
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
368 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
;
372 cfi_add_CFA_restore_state (void)
374 struct cfa_save_data
*p
;
376 cfi_add_CFA_insn (DW_CFA_restore_state
);
378 p
= frchain_now
->frch_cfi_data
->cfa_save_stack
;
381 frchain_now
->frch_cfi_data
->cur_cfa_offset
= p
->cfa_offset
;
382 frchain_now
->frch_cfi_data
->cfa_save_stack
= p
->next
;
386 as_bad (_("CFI state restore without previous remember"));
390 /* Parse CFI assembler directives. */
392 static void dot_cfi (int);
393 static void dot_cfi_escape (int);
394 static void dot_cfi_sections (int);
395 static void dot_cfi_startproc (int);
396 static void dot_cfi_endproc (int);
397 static void dot_cfi_personality (int);
398 static void dot_cfi_lsda (int);
399 static void dot_cfi_val_encoded_addr (int);
401 /* Fake CFI type; outside the byte range of any real CFI insn. */
402 #define CFI_adjust_cfa_offset 0x100
403 #define CFI_return_column 0x101
404 #define CFI_rel_offset 0x102
405 #define CFI_escape 0x103
406 #define CFI_signal_frame 0x104
407 #define CFI_val_encoded_addr 0x105
409 const pseudo_typeS cfi_pseudo_table
[] =
411 { "cfi_sections", dot_cfi_sections
, 0 },
412 { "cfi_startproc", dot_cfi_startproc
, 0 },
413 { "cfi_endproc", dot_cfi_endproc
, 0 },
414 { "cfi_def_cfa", dot_cfi
, DW_CFA_def_cfa
},
415 { "cfi_def_cfa_register", dot_cfi
, DW_CFA_def_cfa_register
},
416 { "cfi_def_cfa_offset", dot_cfi
, DW_CFA_def_cfa_offset
},
417 { "cfi_adjust_cfa_offset", dot_cfi
, CFI_adjust_cfa_offset
},
418 { "cfi_offset", dot_cfi
, DW_CFA_offset
},
419 { "cfi_rel_offset", dot_cfi
, CFI_rel_offset
},
420 { "cfi_register", dot_cfi
, DW_CFA_register
},
421 { "cfi_return_column", dot_cfi
, CFI_return_column
},
422 { "cfi_restore", dot_cfi
, DW_CFA_restore
},
423 { "cfi_undefined", dot_cfi
, DW_CFA_undefined
},
424 { "cfi_same_value", dot_cfi
, DW_CFA_same_value
},
425 { "cfi_remember_state", dot_cfi
, DW_CFA_remember_state
},
426 { "cfi_restore_state", dot_cfi
, DW_CFA_restore_state
},
427 { "cfi_window_save", dot_cfi
, DW_CFA_GNU_window_save
},
428 { "cfi_escape", dot_cfi_escape
, 0 },
429 { "cfi_signal_frame", dot_cfi
, CFI_signal_frame
},
430 { "cfi_personality", dot_cfi_personality
, 0 },
431 { "cfi_lsda", dot_cfi_lsda
, 0 },
432 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr
, 0 },
437 cfi_parse_separator (void)
440 if (*input_line_pointer
== ',')
441 input_line_pointer
++;
443 as_bad (_("missing separator"));
446 #ifndef tc_parse_to_dw2regnum
448 tc_parse_to_dw2regnum(expressionS
*exp
)
450 # ifdef tc_regname_to_dw2regnum
452 if (is_name_beginner (*input_line_pointer
)
453 || (*input_line_pointer
== '%'
454 && is_name_beginner (*++input_line_pointer
)))
458 name
= input_line_pointer
;
459 c
= get_symbol_end ();
461 exp
->X_op
= O_constant
;
462 exp
->X_add_number
= tc_regname_to_dw2regnum (name
);
464 *input_line_pointer
= c
;
468 expression_and_evaluate (exp
);
478 tc_parse_to_dw2regnum (&exp
);
483 regno
= exp
.X_add_number
;
493 as_bad (_("bad register expression"));
501 cfi_parse_const (void)
503 return get_absolute_expression ();
512 if (frchain_now
->frch_cfi_data
== NULL
)
514 as_bad (_("CFI instruction used without previous .cfi_startproc"));
515 ignore_rest_of_line ();
519 /* If the last address was not at the current PC, advance to current. */
520 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
521 || S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
523 cfi_add_advance_loc (symbol_temp_new_now ());
528 reg1
= cfi_parse_reg ();
529 cfi_parse_separator ();
530 offset
= cfi_parse_const ();
531 cfi_add_CFA_offset (reg1
, offset
);
535 reg1
= cfi_parse_reg ();
536 cfi_parse_separator ();
537 offset
= cfi_parse_const ();
538 cfi_add_CFA_offset (reg1
,
539 offset
- frchain_now
->frch_cfi_data
->cur_cfa_offset
);
543 reg1
= cfi_parse_reg ();
544 cfi_parse_separator ();
545 offset
= cfi_parse_const ();
546 cfi_add_CFA_def_cfa (reg1
, offset
);
549 case DW_CFA_register
:
550 reg1
= cfi_parse_reg ();
551 cfi_parse_separator ();
552 reg2
= cfi_parse_reg ();
553 cfi_add_CFA_register (reg1
, reg2
);
556 case DW_CFA_def_cfa_register
:
557 reg1
= cfi_parse_reg ();
558 cfi_add_CFA_def_cfa_register (reg1
);
561 case DW_CFA_def_cfa_offset
:
562 offset
= cfi_parse_const ();
563 cfi_add_CFA_def_cfa_offset (offset
);
566 case CFI_adjust_cfa_offset
:
567 offset
= cfi_parse_const ();
568 cfi_add_CFA_def_cfa_offset (frchain_now
->frch_cfi_data
->cur_cfa_offset
575 reg1
= cfi_parse_reg ();
576 cfi_add_CFA_restore (reg1
);
578 if (*input_line_pointer
!= ',')
580 ++input_line_pointer
;
584 case DW_CFA_undefined
:
587 reg1
= cfi_parse_reg ();
588 cfi_add_CFA_undefined (reg1
);
590 if (*input_line_pointer
!= ',')
592 ++input_line_pointer
;
596 case DW_CFA_same_value
:
597 reg1
= cfi_parse_reg ();
598 cfi_add_CFA_same_value (reg1
);
601 case CFI_return_column
:
602 reg1
= cfi_parse_reg ();
603 cfi_set_return_column (reg1
);
606 case DW_CFA_remember_state
:
607 cfi_add_CFA_remember_state ();
610 case DW_CFA_restore_state
:
611 cfi_add_CFA_restore_state ();
614 case DW_CFA_GNU_window_save
:
615 cfi_add_CFA_insn (DW_CFA_GNU_window_save
);
618 case CFI_signal_frame
:
619 frchain_now
->frch_cfi_data
->cur_fde_data
->signal_frame
= 1;
626 demand_empty_rest_of_line ();
630 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED
)
632 struct cfi_escape_data
*head
, **tail
, *e
;
633 struct cfi_insn_data
*insn
;
635 if (frchain_now
->frch_cfi_data
== NULL
)
637 as_bad (_("CFI instruction used without previous .cfi_startproc"));
638 ignore_rest_of_line ();
642 /* If the last address was not at the current PC, advance to current. */
643 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
644 || S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
646 cfi_add_advance_loc (symbol_temp_new_now ());
651 e
= (struct cfi_escape_data
*) xmalloc (sizeof (*e
));
652 do_parse_cons_expression (&e
->exp
, 1);
656 while (*input_line_pointer
++ == ',');
659 insn
= alloc_cfi_insn_data ();
660 insn
->insn
= CFI_escape
;
663 --input_line_pointer
;
664 demand_empty_rest_of_line ();
668 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED
)
670 struct fde_entry
*fde
;
673 if (frchain_now
->frch_cfi_data
== NULL
)
675 as_bad (_("CFI instruction used without previous .cfi_startproc"));
676 ignore_rest_of_line ();
680 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
681 encoding
= cfi_parse_const ();
682 if (encoding
== DW_EH_PE_omit
)
684 demand_empty_rest_of_line ();
685 fde
->per_encoding
= encoding
;
689 if ((encoding
& 0xff) != encoding
690 || ((encoding
& 0x70) != 0
691 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
692 && (encoding
& 0x70) != DW_EH_PE_pcrel
695 /* leb128 can be handled, but does something actually need it? */
696 || (encoding
& 7) == DW_EH_PE_uleb128
697 || (encoding
& 7) > DW_EH_PE_udata8
)
699 as_bad (_("invalid or unsupported encoding in .cfi_personality"));
700 ignore_rest_of_line ();
704 if (*input_line_pointer
++ != ',')
706 as_bad (_(".cfi_personality requires encoding and symbol arguments"));
707 ignore_rest_of_line ();
711 expression_and_evaluate (&fde
->personality
);
712 switch (fde
->personality
.X_op
)
717 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
718 encoding
= DW_EH_PE_omit
;
721 encoding
= DW_EH_PE_omit
;
725 fde
->per_encoding
= encoding
;
727 if (encoding
== DW_EH_PE_omit
)
729 as_bad (_("wrong second argument to .cfi_personality"));
730 ignore_rest_of_line ();
734 demand_empty_rest_of_line ();
738 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED
)
740 struct fde_entry
*fde
;
743 if (frchain_now
->frch_cfi_data
== NULL
)
745 as_bad (_("CFI instruction used without previous .cfi_startproc"));
746 ignore_rest_of_line ();
750 fde
= frchain_now
->frch_cfi_data
->cur_fde_data
;
751 encoding
= cfi_parse_const ();
752 if (encoding
== DW_EH_PE_omit
)
754 demand_empty_rest_of_line ();
755 fde
->lsda_encoding
= encoding
;
759 if ((encoding
& 0xff) != encoding
760 || ((encoding
& 0x70) != 0
761 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
762 && (encoding
& 0x70) != DW_EH_PE_pcrel
765 /* leb128 can be handled, but does something actually need it? */
766 || (encoding
& 7) == DW_EH_PE_uleb128
767 || (encoding
& 7) > DW_EH_PE_udata8
)
769 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
770 ignore_rest_of_line ();
774 if (*input_line_pointer
++ != ',')
776 as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
777 ignore_rest_of_line ();
781 fde
->lsda_encoding
= encoding
;
783 expression_and_evaluate (&fde
->lsda
);
784 switch (fde
->lsda
.X_op
)
789 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
790 encoding
= DW_EH_PE_omit
;
793 encoding
= DW_EH_PE_omit
;
797 fde
->lsda_encoding
= encoding
;
799 if (encoding
== DW_EH_PE_omit
)
801 as_bad (_("wrong second argument to .cfi_lsda"));
802 ignore_rest_of_line ();
806 demand_empty_rest_of_line ();
810 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED
)
812 struct cfi_insn_data
*insn_ptr
;
815 if (frchain_now
->frch_cfi_data
== NULL
)
817 as_bad (_("CFI instruction used without previous .cfi_startproc"));
818 ignore_rest_of_line ();
822 /* If the last address was not at the current PC, advance to current. */
823 if (symbol_get_frag (frchain_now
->frch_cfi_data
->last_address
) != frag_now
824 || S_GET_VALUE (frchain_now
->frch_cfi_data
->last_address
)
826 cfi_add_advance_loc (symbol_temp_new_now ());
828 insn_ptr
= alloc_cfi_insn_data ();
829 insn_ptr
->insn
= CFI_val_encoded_addr
;
831 insn_ptr
->u
.ea
.reg
= cfi_parse_reg ();
833 cfi_parse_separator ();
834 encoding
= cfi_parse_const ();
835 if ((encoding
& 0xff) != encoding
836 || ((encoding
& 0x70) != 0
837 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
838 && (encoding
& 0x70) != DW_EH_PE_pcrel
841 /* leb128 can be handled, but does something actually need it? */
842 || (encoding
& 7) == DW_EH_PE_uleb128
843 || (encoding
& 7) > DW_EH_PE_udata8
)
845 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
846 encoding
= DW_EH_PE_omit
;
849 cfi_parse_separator ();
850 expression_and_evaluate (&insn_ptr
->u
.ea
.exp
);
851 switch (insn_ptr
->u
.ea
.exp
.X_op
)
856 if ((encoding
& 0x70) != DW_EH_PE_pcrel
)
859 encoding
= DW_EH_PE_omit
;
863 insn_ptr
->u
.ea
.encoding
= encoding
;
864 if (encoding
== DW_EH_PE_omit
)
866 as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
867 ignore_rest_of_line ();
871 demand_empty_rest_of_line ();
874 /* By default emit .eh_frame only, not .debug_frame. */
875 #define CFI_EMIT_eh_frame (1 << 0)
876 #define CFI_EMIT_debug_frame (1 << 1)
877 static int cfi_sections
= CFI_EMIT_eh_frame
;
880 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED
)
885 if (is_name_beginner (*input_line_pointer
))
890 name
= input_line_pointer
;
891 c
= get_symbol_end ();
893 if (strcmp (name
, ".eh_frame") == 0)
894 sections
|= CFI_EMIT_eh_frame
;
895 else if (strcmp (name
, ".debug_frame") == 0)
896 sections
|= CFI_EMIT_debug_frame
;
899 *input_line_pointer
= c
;
900 input_line_pointer
= name
;
904 *input_line_pointer
= c
;
906 if (*input_line_pointer
== ',')
908 name
= input_line_pointer
++;
910 if (!is_name_beginner (*input_line_pointer
))
912 input_line_pointer
= name
;
916 else if (is_name_beginner (*input_line_pointer
))
920 demand_empty_rest_of_line ();
921 cfi_sections
= sections
;
925 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED
)
929 if (frchain_now
->frch_cfi_data
!= NULL
)
931 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
932 ignore_rest_of_line ();
936 cfi_new_fde (symbol_temp_new_now ());
939 if (is_name_beginner (*input_line_pointer
))
943 name
= input_line_pointer
;
944 c
= get_symbol_end ();
946 if (strcmp (name
, "simple") == 0)
949 *input_line_pointer
= c
;
952 input_line_pointer
= name
;
954 demand_empty_rest_of_line ();
956 frchain_now
->frch_cfi_data
->cur_cfa_offset
= 0;
958 tc_cfi_frame_initial_instructions ();
962 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED
)
964 if (frchain_now
->frch_cfi_data
== NULL
)
966 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
967 ignore_rest_of_line ();
971 cfi_end_fde (symbol_temp_new_now ());
973 demand_empty_rest_of_line ();
977 /* Emit a single byte into the current segment. */
982 FRAG_APPEND_1_CHAR (byte
);
985 /* Emit a two-byte word into the current segment. */
990 md_number_to_chars (frag_more (2), data
, 2);
993 /* Emit a four byte word into the current segment. */
998 md_number_to_chars (frag_more (4), data
, 4);
1001 /* Emit an unsigned "little-endian base 128" number. */
1004 out_uleb128 (addressT value
)
1006 output_leb128 (frag_more (sizeof_leb128 (value
, 0)), value
, 0);
1009 /* Emit an unsigned "little-endian base 128" number. */
1012 out_sleb128 (offsetT value
)
1014 output_leb128 (frag_more (sizeof_leb128 (value
, 1)), value
, 1);
1018 output_cfi_insn (struct cfi_insn_data
*insn
)
1025 case DW_CFA_advance_loc
:
1027 symbolS
*from
= insn
->u
.ll
.lab1
;
1028 symbolS
*to
= insn
->u
.ll
.lab2
;
1030 if (symbol_get_frag (to
) == symbol_get_frag (from
))
1032 addressT delta
= S_GET_VALUE (to
) - S_GET_VALUE (from
);
1033 addressT scaled
= delta
/ DWARF2_LINE_MIN_INSN_LENGTH
;
1036 out_one (DW_CFA_advance_loc
+ scaled
);
1037 else if (scaled
<= 0xFF)
1039 out_one (DW_CFA_advance_loc1
);
1042 else if (scaled
<= 0xFFFF)
1044 out_one (DW_CFA_advance_loc2
);
1049 out_one (DW_CFA_advance_loc4
);
1057 exp
.X_op
= O_subtract
;
1058 exp
.X_add_symbol
= to
;
1059 exp
.X_op_symbol
= from
;
1060 exp
.X_add_number
= 0;
1062 /* The code in ehopt.c expects that one byte of the encoding
1063 is already allocated to the frag. This comes from the way
1064 that it scans the .eh_frame section looking first for the
1065 .byte DW_CFA_advance_loc4. */
1066 *frag_more (1) = DW_CFA_advance_loc4
;
1068 frag_var (rs_cfa
, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH
<< 3,
1069 make_expr_symbol (&exp
), frag_now_fix () - 1,
1075 case DW_CFA_def_cfa
:
1076 offset
= insn
->u
.ri
.offset
;
1079 out_one (DW_CFA_def_cfa_sf
);
1080 out_uleb128 (insn
->u
.ri
.reg
);
1081 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1085 out_one (DW_CFA_def_cfa
);
1086 out_uleb128 (insn
->u
.ri
.reg
);
1087 out_uleb128 (offset
);
1091 case DW_CFA_def_cfa_register
:
1092 case DW_CFA_undefined
:
1093 case DW_CFA_same_value
:
1094 out_one (insn
->insn
);
1095 out_uleb128 (insn
->u
.r
);
1098 case DW_CFA_def_cfa_offset
:
1102 out_one (DW_CFA_def_cfa_offset_sf
);
1103 out_sleb128 (offset
/ DWARF2_CIE_DATA_ALIGNMENT
);
1107 out_one (DW_CFA_def_cfa_offset
);
1108 out_uleb128 (offset
);
1112 case DW_CFA_restore
:
1116 out_one (DW_CFA_restore
+ regno
);
1120 out_one (DW_CFA_restore_extended
);
1121 out_uleb128 (regno
);
1126 regno
= insn
->u
.ri
.reg
;
1127 offset
= insn
->u
.ri
.offset
/ DWARF2_CIE_DATA_ALIGNMENT
;
1130 out_one (DW_CFA_offset_extended_sf
);
1131 out_uleb128 (regno
);
1132 out_sleb128 (offset
);
1134 else if (regno
<= 0x3F)
1136 out_one (DW_CFA_offset
+ regno
);
1137 out_uleb128 (offset
);
1141 out_one (DW_CFA_offset_extended
);
1142 out_uleb128 (regno
);
1143 out_uleb128 (offset
);
1147 case DW_CFA_register
:
1148 out_one (DW_CFA_register
);
1149 out_uleb128 (insn
->u
.rr
.reg1
);
1150 out_uleb128 (insn
->u
.rr
.reg2
);
1153 case DW_CFA_remember_state
:
1154 case DW_CFA_restore_state
:
1155 out_one (insn
->insn
);
1158 case DW_CFA_GNU_window_save
:
1159 out_one (DW_CFA_GNU_window_save
);
1164 struct cfi_escape_data
*e
;
1165 for (e
= insn
->u
.esc
; e
; e
= e
->next
)
1166 emit_expr (&e
->exp
, 1);
1170 case CFI_val_encoded_addr
:
1172 unsigned encoding
= insn
->u
.ea
.encoding
;
1173 offsetT encoding_size
;
1175 if (encoding
== DW_EH_PE_omit
)
1177 out_one (DW_CFA_val_expression
);
1178 out_uleb128 (insn
->u
.ea
.reg
);
1180 switch (encoding
& 0x7)
1182 case DW_EH_PE_absptr
:
1183 encoding_size
= DWARF2_ADDR_SIZE (stdoutput
);
1185 case DW_EH_PE_udata2
:
1188 case DW_EH_PE_udata4
:
1191 case DW_EH_PE_udata8
:
1198 /* If the user has requested absolute encoding,
1199 then use the smaller DW_OP_addr encoding. */
1200 if (insn
->u
.ea
.encoding
== DW_EH_PE_absptr
)
1202 out_uleb128 (1 + encoding_size
);
1203 out_one (DW_OP_addr
);
1207 out_uleb128 (1 + 1 + encoding_size
);
1208 out_one (DW_OP_GNU_encoded_addr
);
1211 if ((encoding
& 0x70) == DW_EH_PE_pcrel
)
1213 #if CFI_DIFF_EXPR_OK
1214 insn
->u
.ea
.exp
.X_op
= O_subtract
;
1215 insn
->u
.ea
.exp
.X_op_symbol
= symbol_temp_new_now ();
1216 #elif defined (tc_cfi_emit_pcrel_expr)
1217 tc_cfi_emit_pcrel_expr (&insn
->u
.ea
.exp
, encoding_size
);
1224 emit_expr (&insn
->u
.ea
.exp
, encoding_size
);
1234 encoding_size (unsigned char encoding
)
1236 if (encoding
== DW_EH_PE_omit
)
1238 switch (encoding
& 0x7)
1241 return bfd_get_arch_size (stdoutput
) == 64 ? 8 : 4;
1242 case DW_EH_PE_udata2
:
1244 case DW_EH_PE_udata4
:
1246 case DW_EH_PE_udata8
:
1254 output_cie (struct cie_entry
*cie
, bfd_boolean eh_frame
, int align
)
1256 symbolS
*after_size_address
, *end_address
;
1258 struct cfi_insn_data
*i
;
1259 offsetT augmentation_size
;
1261 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1263 cie
->start_address
= symbol_temp_new_now ();
1264 after_size_address
= symbol_temp_make ();
1265 end_address
= symbol_temp_make ();
1267 exp
.X_op
= O_subtract
;
1268 exp
.X_add_symbol
= end_address
;
1269 exp
.X_op_symbol
= after_size_address
;
1270 exp
.X_add_number
= 0;
1272 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1273 emit_expr (&exp
, 4); /* Length. */
1276 if (fmt
== dwarf2_format_64bit
)
1278 emit_expr (&exp
, 8); /* Length. */
1280 symbol_set_value_now (after_size_address
);
1282 out_four (0); /* CIE id. */
1285 out_four (-1); /* CIE id. */
1286 if (fmt
!= dwarf2_format_32bit
)
1289 out_one (DW_CIE_VERSION
); /* Version. */
1292 out_one ('z'); /* Augmentation. */
1293 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1295 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1298 if (cie
->signal_frame
)
1302 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH
); /* Code alignment. */
1303 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT
); /* Data alignment. */
1304 if (DW_CIE_VERSION
== 1) /* Return column. */
1305 out_one (cie
->return_column
);
1307 out_uleb128 (cie
->return_column
);
1310 augmentation_size
= 1 + (cie
->lsda_encoding
!= DW_EH_PE_omit
);
1311 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1312 augmentation_size
+= 1 + encoding_size (cie
->per_encoding
);
1313 out_uleb128 (augmentation_size
); /* Augmentation size. */
1315 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1317 offsetT size
= encoding_size (cie
->per_encoding
);
1318 out_one (cie
->per_encoding
);
1319 exp
= cie
->personality
;
1320 if ((cie
->per_encoding
& 0x70) == DW_EH_PE_pcrel
)
1322 #if CFI_DIFF_EXPR_OK
1323 exp
.X_op
= O_subtract
;
1324 exp
.X_op_symbol
= symbol_temp_new_now ();
1325 emit_expr (&exp
, size
);
1326 #elif defined (tc_cfi_emit_pcrel_expr)
1327 tc_cfi_emit_pcrel_expr (&exp
, size
);
1333 emit_expr (&exp
, size
);
1335 if (cie
->lsda_encoding
!= DW_EH_PE_omit
)
1336 out_one (cie
->lsda_encoding
);
1338 switch (DWARF2_FDE_RELOC_SIZE
)
1341 enc
= DW_EH_PE_sdata2
;
1344 enc
= DW_EH_PE_sdata4
;
1347 enc
= DW_EH_PE_sdata8
;
1352 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1353 enc
|= DW_EH_PE_pcrel
;
1359 for (i
= cie
->first
; i
!= cie
->last
; i
= i
->next
)
1360 output_cfi_insn (i
);
1362 frag_align (align
, DW_CFA_nop
, 0);
1363 symbol_set_value_now (end_address
);
1367 output_fde (struct fde_entry
*fde
, struct cie_entry
*cie
,
1368 bfd_boolean eh_frame
, struct cfi_insn_data
*first
,
1371 symbolS
*after_size_address
, *end_address
;
1373 offsetT augmentation_size
;
1374 enum dwarf2_format fmt
= DWARF2_FORMAT (now_seg
);
1378 after_size_address
= symbol_temp_make ();
1379 end_address
= symbol_temp_make ();
1381 exp
.X_op
= O_subtract
;
1382 exp
.X_add_symbol
= end_address
;
1383 exp
.X_op_symbol
= after_size_address
;
1384 exp
.X_add_number
= 0;
1385 if (eh_frame
|| fmt
== dwarf2_format_32bit
)
1389 if (fmt
== dwarf2_format_64bit
)
1393 emit_expr (&exp
, offset_size
); /* Length. */
1394 symbol_set_value_now (after_size_address
);
1398 exp
.X_add_symbol
= after_size_address
;
1399 exp
.X_op_symbol
= cie
->start_address
;
1403 exp
.X_op
= O_symbol
;
1404 exp
.X_add_symbol
= cie
->start_address
;
1405 exp
.X_op_symbol
= NULL
;
1407 emit_expr (&exp
, offset_size
); /* CIE offset. */
1411 #if CFI_DIFF_EXPR_OK
1412 exp
.X_add_symbol
= fde
->start_address
;
1413 exp
.X_op_symbol
= symbol_temp_new_now ();
1414 emit_expr (&exp
, DWARF2_FDE_RELOC_SIZE
); /* Code offset. */
1416 exp
.X_op
= O_symbol
;
1417 exp
.X_add_symbol
= fde
->start_address
;
1418 exp
.X_op_symbol
= NULL
;
1419 #ifdef tc_cfi_emit_pcrel_expr
1420 tc_cfi_emit_pcrel_expr (&exp
, DWARF2_FDE_RELOC_SIZE
); /* Code offset. */
1422 emit_expr (&exp
, DWARF2_FDE_RELOC_SIZE
); /* Code offset. */
1425 addr_size
= DWARF2_FDE_RELOC_SIZE
;
1429 exp
.X_add_symbol
= fde
->start_address
;
1430 addr_size
= DWARF2_ADDR_SIZE (stdoutput
);
1431 emit_expr (&exp
, addr_size
);
1434 exp
.X_op
= O_subtract
;
1435 exp
.X_add_symbol
= fde
->end_address
;
1436 exp
.X_op_symbol
= fde
->start_address
; /* Code length. */
1437 emit_expr (&exp
, addr_size
);
1439 augmentation_size
= encoding_size (fde
->lsda_encoding
);
1441 out_uleb128 (augmentation_size
); /* Augmentation size. */
1443 if (fde
->lsda_encoding
!= DW_EH_PE_omit
)
1446 if ((fde
->lsda_encoding
& 0x70) == DW_EH_PE_pcrel
)
1448 #if CFI_DIFF_EXPR_OK
1449 exp
.X_op
= O_subtract
;
1450 exp
.X_op_symbol
= symbol_temp_new_now ();
1451 emit_expr (&exp
, augmentation_size
);
1452 #elif defined (tc_cfi_emit_pcrel_expr)
1453 tc_cfi_emit_pcrel_expr (&exp
, augmentation_size
);
1459 emit_expr (&exp
, augmentation_size
);
1462 for (; first
; first
= first
->next
)
1463 output_cfi_insn (first
);
1465 frag_align (align
, DW_CFA_nop
, 0);
1466 symbol_set_value_now (end_address
);
1469 static struct cie_entry
*
1470 select_cie_for_fde (struct fde_entry
*fde
, bfd_boolean eh_frame
,
1471 struct cfi_insn_data
**pfirst
, int align
)
1473 struct cfi_insn_data
*i
, *j
;
1474 struct cie_entry
*cie
;
1476 for (cie
= cie_root
; cie
; cie
= cie
->next
)
1478 if (cie
->return_column
!= fde
->return_column
1479 || cie
->signal_frame
!= fde
->signal_frame
1480 || cie
->per_encoding
!= fde
->per_encoding
1481 || cie
->lsda_encoding
!= fde
->lsda_encoding
)
1483 if (cie
->per_encoding
!= DW_EH_PE_omit
)
1485 if (cie
->personality
.X_op
!= fde
->personality
.X_op
1486 || cie
->personality
.X_add_number
1487 != fde
->personality
.X_add_number
)
1489 switch (cie
->personality
.X_op
)
1492 if (cie
->personality
.X_unsigned
!= fde
->personality
.X_unsigned
)
1496 if (cie
->personality
.X_add_symbol
1497 != fde
->personality
.X_add_symbol
)
1504 for (i
= cie
->first
, j
= fde
->data
;
1505 i
!= cie
->last
&& j
!= NULL
;
1506 i
= i
->next
, j
= j
->next
)
1508 if (i
->insn
!= j
->insn
)
1512 case DW_CFA_advance_loc
:
1513 case DW_CFA_remember_state
:
1514 /* We reached the first advance/remember in the FDE,
1515 but did not reach the end of the CIE list. */
1519 case DW_CFA_def_cfa
:
1520 if (i
->u
.ri
.reg
!= j
->u
.ri
.reg
)
1522 if (i
->u
.ri
.offset
!= j
->u
.ri
.offset
)
1526 case DW_CFA_register
:
1527 if (i
->u
.rr
.reg1
!= j
->u
.rr
.reg1
)
1529 if (i
->u
.rr
.reg2
!= j
->u
.rr
.reg2
)
1533 case DW_CFA_def_cfa_register
:
1534 case DW_CFA_restore
:
1535 case DW_CFA_undefined
:
1536 case DW_CFA_same_value
:
1537 if (i
->u
.r
!= j
->u
.r
)
1541 case DW_CFA_def_cfa_offset
:
1542 if (i
->u
.i
!= j
->u
.i
)
1547 case CFI_val_encoded_addr
:
1548 /* Don't bother matching these for now. */
1556 /* Success if we reached the end of the CIE list, and we've either
1557 run out of FDE entries or we've encountered an advance,
1558 remember, or escape. */
1561 || j
->insn
== DW_CFA_advance_loc
1562 || j
->insn
== DW_CFA_remember_state
1563 || j
->insn
== CFI_escape
1564 || j
->insn
== CFI_val_encoded_addr
))
1573 cie
= (struct cie_entry
*) xmalloc (sizeof (struct cie_entry
));
1574 cie
->next
= cie_root
;
1576 cie
->return_column
= fde
->return_column
;
1577 cie
->signal_frame
= fde
->signal_frame
;
1578 cie
->per_encoding
= fde
->per_encoding
;
1579 cie
->lsda_encoding
= fde
->lsda_encoding
;
1580 cie
->personality
= fde
->personality
;
1581 cie
->first
= fde
->data
;
1583 for (i
= cie
->first
; i
; i
= i
->next
)
1584 if (i
->insn
== DW_CFA_advance_loc
1585 || i
->insn
== DW_CFA_remember_state
1586 || i
->insn
== CFI_escape
1587 || i
->insn
== CFI_val_encoded_addr
)
1593 output_cie (cie
, eh_frame
, align
);
1598 #ifdef md_reg_eh_frame_to_debug_frame
1600 cfi_change_reg_numbers (struct cfi_insn_data
*insn
)
1602 for (; insn
; insn
= insn
->next
)
1605 case DW_CFA_advance_loc
:
1606 case DW_CFA_def_cfa_offset
:
1607 case DW_CFA_remember_state
:
1608 case DW_CFA_restore_state
:
1609 case DW_CFA_GNU_window_save
:
1613 case DW_CFA_def_cfa
:
1615 insn
->u
.ri
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ri
.reg
);
1618 case DW_CFA_def_cfa_register
:
1619 case DW_CFA_undefined
:
1620 case DW_CFA_same_value
:
1621 case DW_CFA_restore
:
1622 insn
->u
.r
= md_reg_eh_frame_to_debug_frame (insn
->u
.r
);
1625 case DW_CFA_register
:
1626 insn
->u
.rr
.reg1
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg1
);
1627 insn
->u
.rr
.reg2
= md_reg_eh_frame_to_debug_frame (insn
->u
.rr
.reg2
);
1630 case CFI_val_encoded_addr
:
1631 insn
->u
.ea
.reg
= md_reg_eh_frame_to_debug_frame (insn
->u
.ea
.reg
);
1639 #define cfi_change_reg_numbers(insn) do { } while (0)
1646 struct fde_entry
*fde
;
1647 int save_flag_traditional_format
;
1649 if (all_fde_data
== 0)
1652 if ((cfi_sections
& CFI_EMIT_eh_frame
) != 0)
1654 /* Open .eh_frame section. */
1655 cfi_seg
= subseg_new (".eh_frame", 0);
1656 bfd_set_section_flags (stdoutput
, cfi_seg
,
1657 SEC_ALLOC
| SEC_LOAD
| SEC_DATA
1658 | DWARF2_EH_FRAME_READ_ONLY
);
1659 subseg_set (cfi_seg
, 0);
1660 record_alignment (cfi_seg
, EH_FRAME_ALIGNMENT
);
1662 #ifdef md_fix_up_eh_frame
1663 md_fix_up_eh_frame (cfi_seg
);
1666 /* Make sure check_eh_frame doesn't do anything with our output. */
1667 save_flag_traditional_format
= flag_traditional_format
;
1668 flag_traditional_format
= 1;
1670 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1672 struct cfi_insn_data
*first
;
1673 struct cie_entry
*cie
;
1675 if (fde
->end_address
== NULL
)
1677 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1678 fde
->end_address
= fde
->start_address
;
1681 cie
= select_cie_for_fde (fde
, TRUE
, &first
, 2);
1682 output_fde (fde
, cie
, TRUE
, first
,
1683 fde
->next
== NULL
? EH_FRAME_ALIGNMENT
: 2);
1686 flag_traditional_format
= save_flag_traditional_format
;
1689 if ((cfi_sections
& CFI_EMIT_debug_frame
) != 0)
1691 struct cie_entry
*cie
, *cie_next
;
1692 int alignment
= ffs (DWARF2_ADDR_SIZE (stdoutput
)) - 1;
1694 for (cie
= cie_root
; cie
; cie
= cie_next
)
1696 cie_next
= cie
->next
;
1697 free ((void *) cie
);
1701 /* Open .debug_frame section. */
1702 cfi_seg
= subseg_new (".debug_frame", 0);
1703 bfd_set_section_flags (stdoutput
, cfi_seg
,
1704 SEC_READONLY
| SEC_DEBUGGING
);
1705 subseg_set (cfi_seg
, 0);
1706 record_alignment (cfi_seg
, alignment
);
1708 for (fde
= all_fde_data
; fde
; fde
= fde
->next
)
1710 struct cfi_insn_data
*first
;
1711 struct cie_entry
*cie
;
1713 if (fde
->end_address
== NULL
)
1715 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1716 fde
->end_address
= fde
->start_address
;
1719 fde
->per_encoding
= DW_EH_PE_omit
;
1720 fde
->lsda_encoding
= DW_EH_PE_omit
;
1721 cfi_change_reg_numbers (fde
->data
);
1722 cie
= select_cie_for_fde (fde
, FALSE
, &first
, alignment
);
1723 output_fde (fde
, cie
, FALSE
, first
, alignment
);
1728 #else /* TARGET_USE_CFIPOP */
1733 #endif /* TARGET_USE_CFIPOP */