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