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 */