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 #if defined (TE_PE) || defined (TE_PEP)
80 #define SUPPORT_FRAME_LINKONCE 1
82 #define SUPPORT_FRAME_LINKONCE 0
85 #if SUPPORT_FRAME_LINKONCE
86 #define CUR_SEG(structp) structp->cur_seg
87 #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg
88 #define HANDLED(structp) structp->handled
89 #define SET_HANDLED(structp, val) structp->handled = val
91 #define CUR_SEG(structp) NULL
92 #define SET_CUR_SEG(structp, seg) (void) (0 && seg)
93 #define HANDLED(structp) 0
94 #define SET_HANDLED(structp, val) (void) (0 && val)
97 /* Private segment collection list. */
105 #define FRAME_NAME ".eh_frame"
107 static struct hash_control *dwcfi_hash;
109 /* Build based on segment the derived .debug_...
110 segment name containing origin segment's postfix name part. */
113 get_debugseg_name (segT seg, const char *base_name)
124 name = bfd_get_section_name (stdoutput, seg);
126 dollar = strchr (name, '$');
127 dot = strchr (name + 1, '.');
135 else if (dot < dollar)
141 return concat (base_name, name, NULL);
144 /* Allocate a dwcfi_seg_list structure. */
146 static struct dwcfi_seg_list *
147 alloc_debugseg_item (segT seg, int subseg, char *name)
149 struct dwcfi_seg_list *r;
151 r = (struct dwcfi_seg_list *)
152 xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name));
160 is_now_linkonce_segment (void)
162 if ((bfd_get_section_flags (stdoutput, now_seg)
163 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
164 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
165 | SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0)
170 /* Generate debug... segment with same linkonce properties
174 make_debug_seg (segT cseg, char *name, int sflags)
176 segT save_seg = now_seg;
177 int save_subseg = now_subseg;
181 r = subseg_new (name, 0);
183 /* Check if code segment is marked as linked once. */
187 flags = bfd_get_section_flags (stdoutput, cseg)
188 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
189 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
190 | SEC_LINK_DUPLICATES_SAME_CONTENTS);
192 /* Add standard section flags. */
195 /* Apply possibly linked once flags to new generated segment, too. */
196 if (!bfd_set_section_flags (stdoutput, r, flags))
197 as_bad (_("bfd_set_section_flags: %s"),
198 bfd_errmsg (bfd_get_error ()));
200 /* Restore to previous segment. */
201 if (save_seg != NULL)
202 subseg_set (save_seg, save_subseg);
207 dwcfi_hash_insert (const char *name, struct dwcfi_seg_list *item)
209 const char *error_string;
211 if ((error_string = hash_jam (dwcfi_hash, name, (char *) item)))
212 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
216 static struct dwcfi_seg_list *
217 dwcfi_hash_find (char *name)
219 return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name);
222 static struct dwcfi_seg_list *
223 dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags)
225 struct dwcfi_seg_list *item;
228 /* Initialize dwcfi_hash once. */
230 dwcfi_hash = hash_new ();
232 name = get_debugseg_name (cseg, base_name);
234 item = dwcfi_hash_find (name);
237 item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name);
239 dwcfi_hash_insert (item->seg_name, item);
247 /* ??? Share this with dwarf2cfg.c. */
248 #ifndef TC_DWARF2_EMIT_OFFSET
249 #define TC_DWARF2_EMIT_OFFSET generic_dwarf2_emit_offset
251 /* Create an offset to .dwarf2_*. */
254 generic_dwarf2_emit_offset (symbolS *symbol, unsigned int size)
259 exp.X_add_symbol = symbol;
260 exp.X_add_number = 0;
261 emit_expr (&exp, size);
265 struct cfi_escape_data
267 struct cfi_escape_data *next;
273 struct cfi_insn_data *next;
274 #if SUPPORT_FRAME_LINKONCE
301 struct cfi_escape_data *esc;
305 unsigned reg, encoding;
313 struct fde_entry *next;
314 #if SUPPORT_FRAME_LINKONCE
317 symbolS *start_address;
318 symbolS *end_address;
319 struct cfi_insn_data *data;
320 struct cfi_insn_data **last;
321 unsigned char per_encoding;
322 unsigned char lsda_encoding;
323 expressionS personality;
325 unsigned int return_column;
326 unsigned int signal_frame;
327 #if SUPPORT_FRAME_LINKONCE
334 struct cie_entry *next;
335 #if SUPPORT_FRAME_LINKONCE
338 symbolS *start_address;
339 unsigned int return_column;
340 unsigned int signal_frame;
341 unsigned char per_encoding;
342 unsigned char lsda_encoding;
343 expressionS personality;
344 struct cfi_insn_data *first, *last;
347 /* List of FDE entries. */
349 static struct fde_entry *all_fde_data;
350 static struct fde_entry **last_fde_data = &all_fde_data;
352 /* List of CIEs so that they could be reused. */
353 static struct cie_entry *cie_root;
355 /* Stack of old CFI data, for save/restore. */
358 struct cfa_save_data *next;
362 /* Current open FDE entry. */
365 struct fde_entry *cur_fde_data;
366 symbolS *last_address;
367 offsetT cur_cfa_offset;
368 struct cfa_save_data *cfa_save_stack;
371 /* Construct a new FDE structure and add it to the end of the fde list. */
373 static struct fde_entry *
374 alloc_fde_entry (void)
376 struct fde_entry *fde = (struct fde_entry *)
377 xcalloc (1, sizeof (struct fde_entry));
379 frchain_now->frch_cfi_data = (struct frch_cfi_data *)
380 xcalloc (1, sizeof (struct frch_cfi_data));
381 frchain_now->frch_cfi_data->cur_fde_data = fde;
382 *last_fde_data = fde;
383 last_fde_data = &fde->next;
384 SET_CUR_SEG (fde, is_now_linkonce_segment ());
385 SET_HANDLED (fde, 0);
386 fde->last = &fde->data;
387 fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
388 fde->per_encoding = DW_EH_PE_omit;
389 fde->lsda_encoding = DW_EH_PE_omit;
394 /* The following functions are available for a backend to construct its
395 own unwind information, usually from legacy unwind directives. */
397 /* Construct a new INSN structure and add it to the end of the insn list
398 for the currently active FDE. */
400 static struct cfi_insn_data *
401 alloc_cfi_insn_data (void)
403 struct cfi_insn_data *insn = (struct cfi_insn_data *)
404 xcalloc (1, sizeof (struct cfi_insn_data));
405 struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data;
407 *cur_fde_data->last = insn;
408 cur_fde_data->last = &insn->next;
409 SET_CUR_SEG (insn, is_now_linkonce_segment ());
413 /* Construct a new FDE structure that begins at LABEL. */
416 cfi_new_fde (symbolS *label)
418 struct fde_entry *fde = alloc_fde_entry ();
419 fde->start_address = label;
420 frchain_now->frch_cfi_data->last_address = label;
423 /* End the currently open FDE. */
426 cfi_end_fde (symbolS *label)
428 frchain_now->frch_cfi_data->cur_fde_data->end_address = label;
429 free (frchain_now->frch_cfi_data);
430 frchain_now->frch_cfi_data = NULL;
433 /* Set the return column for the current FDE. */
436 cfi_set_return_column (unsigned regno)
438 frchain_now->frch_cfi_data->cur_fde_data->return_column = regno;
441 /* Universal functions to store new instructions. */
444 cfi_add_CFA_insn (int insn)
446 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
448 insn_ptr->insn = insn;
452 cfi_add_CFA_insn_reg (int insn, unsigned regno)
454 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
456 insn_ptr->insn = insn;
457 insn_ptr->u.r = regno;
461 cfi_add_CFA_insn_offset (int insn, offsetT offset)
463 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
465 insn_ptr->insn = insn;
466 insn_ptr->u.i = offset;
470 cfi_add_CFA_insn_reg_reg (int insn, unsigned reg1, unsigned reg2)
472 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
474 insn_ptr->insn = insn;
475 insn_ptr->u.rr.reg1 = reg1;
476 insn_ptr->u.rr.reg2 = reg2;
480 cfi_add_CFA_insn_reg_offset (int insn, unsigned regno, offsetT offset)
482 struct cfi_insn_data *insn_ptr = alloc_cfi_insn_data ();
484 insn_ptr->insn = insn;
485 insn_ptr->u.ri.reg = regno;
486 insn_ptr->u.ri.offset = offset;
489 /* Add a CFI insn to advance the PC from the last address to LABEL. */
492 cfi_add_advance_loc (symbolS *label)
494 struct cfi_insn_data *insn = alloc_cfi_insn_data ();
496 insn->insn = DW_CFA_advance_loc;
497 insn->u.ll.lab1 = frchain_now->frch_cfi_data->last_address;
498 insn->u.ll.lab2 = label;
500 frchain_now->frch_cfi_data->last_address = label;
503 /* Add a DW_CFA_offset record to the CFI data. */
506 cfi_add_CFA_offset (unsigned regno, offsetT offset)
508 unsigned int abs_data_align;
510 gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0);
511 cfi_add_CFA_insn_reg_offset (DW_CFA_offset, regno, offset);
513 abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0
514 ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT);
515 if (offset % abs_data_align)
516 as_bad (_("register save offset not a multiple of %u"), abs_data_align);
519 /* Add a DW_CFA_def_cfa record to the CFI data. */
522 cfi_add_CFA_def_cfa (unsigned regno, offsetT offset)
524 cfi_add_CFA_insn_reg_offset (DW_CFA_def_cfa, regno, offset);
525 frchain_now->frch_cfi_data->cur_cfa_offset = offset;
528 /* Add a DW_CFA_register record to the CFI data. */
531 cfi_add_CFA_register (unsigned reg1, unsigned reg2)
533 cfi_add_CFA_insn_reg_reg (DW_CFA_register, reg1, reg2);
536 /* Add a DW_CFA_def_cfa_register record to the CFI data. */
539 cfi_add_CFA_def_cfa_register (unsigned regno)
541 cfi_add_CFA_insn_reg (DW_CFA_def_cfa_register, regno);
544 /* Add a DW_CFA_def_cfa_offset record to the CFI data. */
547 cfi_add_CFA_def_cfa_offset (offsetT offset)
549 cfi_add_CFA_insn_offset (DW_CFA_def_cfa_offset, offset);
550 frchain_now->frch_cfi_data->cur_cfa_offset = offset;
554 cfi_add_CFA_restore (unsigned regno)
556 cfi_add_CFA_insn_reg (DW_CFA_restore, regno);
560 cfi_add_CFA_undefined (unsigned regno)
562 cfi_add_CFA_insn_reg (DW_CFA_undefined, regno);
566 cfi_add_CFA_same_value (unsigned regno)
568 cfi_add_CFA_insn_reg (DW_CFA_same_value, regno);
572 cfi_add_CFA_remember_state (void)
574 struct cfa_save_data *p;
576 cfi_add_CFA_insn (DW_CFA_remember_state);
578 p = (struct cfa_save_data *) xmalloc (sizeof (*p));
579 p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset;
580 p->next = frchain_now->frch_cfi_data->cfa_save_stack;
581 frchain_now->frch_cfi_data->cfa_save_stack = p;
585 cfi_add_CFA_restore_state (void)
587 struct cfa_save_data *p;
589 cfi_add_CFA_insn (DW_CFA_restore_state);
591 p = frchain_now->frch_cfi_data->cfa_save_stack;
594 frchain_now->frch_cfi_data->cur_cfa_offset = p->cfa_offset;
595 frchain_now->frch_cfi_data->cfa_save_stack = p->next;
599 as_bad (_("CFI state restore without previous remember"));
603 /* Parse CFI assembler directives. */
605 static void dot_cfi (int);
606 static void dot_cfi_escape (int);
607 static void dot_cfi_sections (int);
608 static void dot_cfi_startproc (int);
609 static void dot_cfi_endproc (int);
610 static void dot_cfi_personality (int);
611 static void dot_cfi_lsda (int);
612 static void dot_cfi_val_encoded_addr (int);
614 /* Fake CFI type; outside the byte range of any real CFI insn. */
615 #define CFI_adjust_cfa_offset 0x100
616 #define CFI_return_column 0x101
617 #define CFI_rel_offset 0x102
618 #define CFI_escape 0x103
619 #define CFI_signal_frame 0x104
620 #define CFI_val_encoded_addr 0x105
622 const pseudo_typeS cfi_pseudo_table[] =
624 { "cfi_sections", dot_cfi_sections, 0 },
625 { "cfi_startproc", dot_cfi_startproc, 0 },
626 { "cfi_endproc", dot_cfi_endproc, 0 },
627 { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa },
628 { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register },
629 { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset },
630 { "cfi_adjust_cfa_offset", dot_cfi, CFI_adjust_cfa_offset },
631 { "cfi_offset", dot_cfi, DW_CFA_offset },
632 { "cfi_rel_offset", dot_cfi, CFI_rel_offset },
633 { "cfi_register", dot_cfi, DW_CFA_register },
634 { "cfi_return_column", dot_cfi, CFI_return_column },
635 { "cfi_restore", dot_cfi, DW_CFA_restore },
636 { "cfi_undefined", dot_cfi, DW_CFA_undefined },
637 { "cfi_same_value", dot_cfi, DW_CFA_same_value },
638 { "cfi_remember_state", dot_cfi, DW_CFA_remember_state },
639 { "cfi_restore_state", dot_cfi, DW_CFA_restore_state },
640 { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save },
641 { "cfi_escape", dot_cfi_escape, 0 },
642 { "cfi_signal_frame", dot_cfi, CFI_signal_frame },
643 { "cfi_personality", dot_cfi_personality, 0 },
644 { "cfi_lsda", dot_cfi_lsda, 0 },
645 { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 },
650 cfi_parse_separator (void)
653 if (*input_line_pointer == ',')
654 input_line_pointer++;
656 as_bad (_("missing separator"));
659 #ifndef tc_parse_to_dw2regnum
661 tc_parse_to_dw2regnum (expressionS *exp)
663 # ifdef tc_regname_to_dw2regnum
665 if (is_name_beginner (*input_line_pointer)
666 || (*input_line_pointer == '%'
667 && is_name_beginner (*++input_line_pointer)))
671 name = input_line_pointer;
672 c = get_symbol_end ();
674 exp->X_op = O_constant;
675 exp->X_add_number = tc_regname_to_dw2regnum (name);
677 *input_line_pointer = c;
681 expression_and_evaluate (exp);
691 tc_parse_to_dw2regnum (&exp);
696 regno = exp.X_add_number;
706 as_bad (_("bad register expression"));
714 cfi_parse_const (void)
716 return get_absolute_expression ();
725 if (frchain_now->frch_cfi_data == NULL)
727 as_bad (_("CFI instruction used without previous .cfi_startproc"));
728 ignore_rest_of_line ();
732 /* If the last address was not at the current PC, advance to current. */
733 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
734 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
736 cfi_add_advance_loc (symbol_temp_new_now ());
741 reg1 = cfi_parse_reg ();
742 cfi_parse_separator ();
743 offset = cfi_parse_const ();
744 cfi_add_CFA_offset (reg1, offset);
748 reg1 = cfi_parse_reg ();
749 cfi_parse_separator ();
750 offset = cfi_parse_const ();
751 cfi_add_CFA_offset (reg1,
752 offset - frchain_now->frch_cfi_data->cur_cfa_offset);
756 reg1 = cfi_parse_reg ();
757 cfi_parse_separator ();
758 offset = cfi_parse_const ();
759 cfi_add_CFA_def_cfa (reg1, offset);
762 case DW_CFA_register:
763 reg1 = cfi_parse_reg ();
764 cfi_parse_separator ();
765 reg2 = cfi_parse_reg ();
766 cfi_add_CFA_register (reg1, reg2);
769 case DW_CFA_def_cfa_register:
770 reg1 = cfi_parse_reg ();
771 cfi_add_CFA_def_cfa_register (reg1);
774 case DW_CFA_def_cfa_offset:
775 offset = cfi_parse_const ();
776 cfi_add_CFA_def_cfa_offset (offset);
779 case CFI_adjust_cfa_offset:
780 offset = cfi_parse_const ();
781 cfi_add_CFA_def_cfa_offset (frchain_now->frch_cfi_data->cur_cfa_offset
788 reg1 = cfi_parse_reg ();
789 cfi_add_CFA_restore (reg1);
791 if (*input_line_pointer != ',')
793 ++input_line_pointer;
797 case DW_CFA_undefined:
800 reg1 = cfi_parse_reg ();
801 cfi_add_CFA_undefined (reg1);
803 if (*input_line_pointer != ',')
805 ++input_line_pointer;
809 case DW_CFA_same_value:
810 reg1 = cfi_parse_reg ();
811 cfi_add_CFA_same_value (reg1);
814 case CFI_return_column:
815 reg1 = cfi_parse_reg ();
816 cfi_set_return_column (reg1);
819 case DW_CFA_remember_state:
820 cfi_add_CFA_remember_state ();
823 case DW_CFA_restore_state:
824 cfi_add_CFA_restore_state ();
827 case DW_CFA_GNU_window_save:
828 cfi_add_CFA_insn (DW_CFA_GNU_window_save);
831 case CFI_signal_frame:
832 frchain_now->frch_cfi_data->cur_fde_data->signal_frame = 1;
839 demand_empty_rest_of_line ();
843 dot_cfi_escape (int ignored ATTRIBUTE_UNUSED)
845 struct cfi_escape_data *head, **tail, *e;
846 struct cfi_insn_data *insn;
848 if (frchain_now->frch_cfi_data == NULL)
850 as_bad (_("CFI instruction used without previous .cfi_startproc"));
851 ignore_rest_of_line ();
855 /* If the last address was not at the current PC, advance to current. */
856 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
857 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
859 cfi_add_advance_loc (symbol_temp_new_now ());
864 e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
865 do_parse_cons_expression (&e->exp, 1);
869 while (*input_line_pointer++ == ',');
872 insn = alloc_cfi_insn_data ();
873 insn->insn = CFI_escape;
876 --input_line_pointer;
877 demand_empty_rest_of_line ();
881 dot_cfi_personality (int ignored ATTRIBUTE_UNUSED)
883 struct fde_entry *fde;
886 if (frchain_now->frch_cfi_data == NULL)
888 as_bad (_("CFI instruction used without previous .cfi_startproc"));
889 ignore_rest_of_line ();
893 fde = frchain_now->frch_cfi_data->cur_fde_data;
894 encoding = cfi_parse_const ();
895 if (encoding == DW_EH_PE_omit)
897 demand_empty_rest_of_line ();
898 fde->per_encoding = encoding;
902 if ((encoding & 0xff) != encoding
903 || ((encoding & 0x70) != 0
904 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
905 && (encoding & 0x70) != DW_EH_PE_pcrel
908 /* leb128 can be handled, but does something actually need it? */
909 || (encoding & 7) == DW_EH_PE_uleb128
910 || (encoding & 7) > DW_EH_PE_udata8)
912 as_bad (_("invalid or unsupported encoding in .cfi_personality"));
913 ignore_rest_of_line ();
917 if (*input_line_pointer++ != ',')
919 as_bad (_(".cfi_personality requires encoding and symbol arguments"));
920 ignore_rest_of_line ();
924 expression_and_evaluate (&fde->personality);
925 switch (fde->personality.X_op)
930 if ((encoding & 0x70) == DW_EH_PE_pcrel)
931 encoding = DW_EH_PE_omit;
934 encoding = DW_EH_PE_omit;
938 fde->per_encoding = encoding;
940 if (encoding == DW_EH_PE_omit)
942 as_bad (_("wrong second argument to .cfi_personality"));
943 ignore_rest_of_line ();
947 demand_empty_rest_of_line ();
951 dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED)
953 struct fde_entry *fde;
956 if (frchain_now->frch_cfi_data == NULL)
958 as_bad (_("CFI instruction used without previous .cfi_startproc"));
959 ignore_rest_of_line ();
963 fde = frchain_now->frch_cfi_data->cur_fde_data;
964 encoding = cfi_parse_const ();
965 if (encoding == DW_EH_PE_omit)
967 demand_empty_rest_of_line ();
968 fde->lsda_encoding = encoding;
972 if ((encoding & 0xff) != encoding
973 || ((encoding & 0x70) != 0
974 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr
975 && (encoding & 0x70) != DW_EH_PE_pcrel
978 /* leb128 can be handled, but does something actually need it? */
979 || (encoding & 7) == DW_EH_PE_uleb128
980 || (encoding & 7) > DW_EH_PE_udata8)
982 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
983 ignore_rest_of_line ();
987 if (*input_line_pointer++ != ',')
989 as_bad (_(".cfi_lsda requires encoding and symbol arguments"));
990 ignore_rest_of_line ();
994 fde->lsda_encoding = encoding;
996 expression_and_evaluate (&fde->lsda);
997 switch (fde->lsda.X_op)
1002 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1003 encoding = DW_EH_PE_omit;
1006 encoding = DW_EH_PE_omit;
1010 fde->lsda_encoding = encoding;
1012 if (encoding == DW_EH_PE_omit)
1014 as_bad (_("wrong second argument to .cfi_lsda"));
1015 ignore_rest_of_line ();
1019 demand_empty_rest_of_line ();
1023 dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED)
1025 struct cfi_insn_data *insn_ptr;
1028 if (frchain_now->frch_cfi_data == NULL)
1030 as_bad (_("CFI instruction used without previous .cfi_startproc"));
1031 ignore_rest_of_line ();
1035 /* If the last address was not at the current PC, advance to current. */
1036 if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now
1037 || S_GET_VALUE (frchain_now->frch_cfi_data->last_address)
1039 cfi_add_advance_loc (symbol_temp_new_now ());
1041 insn_ptr = alloc_cfi_insn_data ();
1042 insn_ptr->insn = CFI_val_encoded_addr;
1044 insn_ptr->u.ea.reg = cfi_parse_reg ();
1046 cfi_parse_separator ();
1047 encoding = cfi_parse_const ();
1048 if ((encoding & 0xff) != encoding
1049 || ((encoding & 0x70) != 0
1050 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1051 && (encoding & 0x70) != DW_EH_PE_pcrel
1054 /* leb128 can be handled, but does something actually need it? */
1055 || (encoding & 7) == DW_EH_PE_uleb128
1056 || (encoding & 7) > DW_EH_PE_udata8)
1058 as_bad (_("invalid or unsupported encoding in .cfi_lsda"));
1059 encoding = DW_EH_PE_omit;
1062 cfi_parse_separator ();
1063 expression_and_evaluate (&insn_ptr->u.ea.exp);
1064 switch (insn_ptr->u.ea.exp.X_op)
1069 if ((encoding & 0x70) != DW_EH_PE_pcrel)
1072 encoding = DW_EH_PE_omit;
1076 insn_ptr->u.ea.encoding = encoding;
1077 if (encoding == DW_EH_PE_omit)
1079 as_bad (_("wrong third argument to .cfi_val_encoded_addr"));
1080 ignore_rest_of_line ();
1084 demand_empty_rest_of_line ();
1087 /* By default emit .eh_frame only, not .debug_frame. */
1088 #define CFI_EMIT_eh_frame (1 << 0)
1089 #define CFI_EMIT_debug_frame (1 << 1)
1090 static int cfi_sections = CFI_EMIT_eh_frame;
1093 dot_cfi_sections (int ignored ATTRIBUTE_UNUSED)
1098 if (is_name_beginner (*input_line_pointer))
1103 name = input_line_pointer;
1104 c = get_symbol_end ();
1106 if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0
1108 sections |= CFI_EMIT_eh_frame;
1109 else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0)
1110 sections |= CFI_EMIT_debug_frame;
1113 *input_line_pointer = c;
1114 input_line_pointer = name;
1118 *input_line_pointer = c;
1120 if (*input_line_pointer == ',')
1122 name = input_line_pointer++;
1124 if (!is_name_beginner (*input_line_pointer))
1126 input_line_pointer = name;
1130 else if (is_name_beginner (*input_line_pointer))
1134 demand_empty_rest_of_line ();
1135 cfi_sections = sections;
1139 dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED)
1143 if (frchain_now->frch_cfi_data != NULL)
1145 as_bad (_("previous CFI entry not closed (missing .cfi_endproc)"));
1146 ignore_rest_of_line ();
1150 cfi_new_fde (symbol_temp_new_now ());
1153 if (is_name_beginner (*input_line_pointer))
1157 name = input_line_pointer;
1158 c = get_symbol_end ();
1160 if (strcmp (name, "simple") == 0)
1163 *input_line_pointer = c;
1166 input_line_pointer = name;
1168 demand_empty_rest_of_line ();
1170 frchain_now->frch_cfi_data->cur_cfa_offset = 0;
1172 tc_cfi_frame_initial_instructions ();
1176 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
1178 if (frchain_now->frch_cfi_data == NULL)
1180 as_bad (_(".cfi_endproc without corresponding .cfi_startproc"));
1181 ignore_rest_of_line ();
1185 cfi_end_fde (symbol_temp_new_now ());
1187 demand_empty_rest_of_line ();
1191 /* Emit a single byte into the current segment. */
1196 FRAG_APPEND_1_CHAR (byte);
1199 /* Emit a two-byte word into the current segment. */
1204 md_number_to_chars (frag_more (2), data, 2);
1207 /* Emit a four byte word into the current segment. */
1212 md_number_to_chars (frag_more (4), data, 4);
1215 /* Emit an unsigned "little-endian base 128" number. */
1218 out_uleb128 (addressT value)
1220 output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0);
1223 /* Emit an unsigned "little-endian base 128" number. */
1226 out_sleb128 (offsetT value)
1228 output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1);
1232 output_cfi_insn (struct cfi_insn_data *insn)
1239 case DW_CFA_advance_loc:
1241 symbolS *from = insn->u.ll.lab1;
1242 symbolS *to = insn->u.ll.lab2;
1244 if (symbol_get_frag (to) == symbol_get_frag (from))
1246 addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from);
1247 addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH;
1250 out_one (DW_CFA_advance_loc + scaled);
1251 else if (scaled <= 0xFF)
1253 out_one (DW_CFA_advance_loc1);
1256 else if (scaled <= 0xFFFF)
1258 out_one (DW_CFA_advance_loc2);
1263 out_one (DW_CFA_advance_loc4);
1271 exp.X_op = O_subtract;
1272 exp.X_add_symbol = to;
1273 exp.X_op_symbol = from;
1274 exp.X_add_number = 0;
1276 /* The code in ehopt.c expects that one byte of the encoding
1277 is already allocated to the frag. This comes from the way
1278 that it scans the .eh_frame section looking first for the
1279 .byte DW_CFA_advance_loc4. */
1280 *frag_more (1) = DW_CFA_advance_loc4;
1282 frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3,
1283 make_expr_symbol (&exp), frag_now_fix () - 1,
1289 case DW_CFA_def_cfa:
1290 offset = insn->u.ri.offset;
1293 out_one (DW_CFA_def_cfa_sf);
1294 out_uleb128 (insn->u.ri.reg);
1295 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1299 out_one (DW_CFA_def_cfa);
1300 out_uleb128 (insn->u.ri.reg);
1301 out_uleb128 (offset);
1305 case DW_CFA_def_cfa_register:
1306 case DW_CFA_undefined:
1307 case DW_CFA_same_value:
1308 out_one (insn->insn);
1309 out_uleb128 (insn->u.r);
1312 case DW_CFA_def_cfa_offset:
1316 out_one (DW_CFA_def_cfa_offset_sf);
1317 out_sleb128 (offset / DWARF2_CIE_DATA_ALIGNMENT);
1321 out_one (DW_CFA_def_cfa_offset);
1322 out_uleb128 (offset);
1326 case DW_CFA_restore:
1330 out_one (DW_CFA_restore + regno);
1334 out_one (DW_CFA_restore_extended);
1335 out_uleb128 (regno);
1340 regno = insn->u.ri.reg;
1341 offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT;
1344 out_one (DW_CFA_offset_extended_sf);
1345 out_uleb128 (regno);
1346 out_sleb128 (offset);
1348 else if (regno <= 0x3F)
1350 out_one (DW_CFA_offset + regno);
1351 out_uleb128 (offset);
1355 out_one (DW_CFA_offset_extended);
1356 out_uleb128 (regno);
1357 out_uleb128 (offset);
1361 case DW_CFA_register:
1362 out_one (DW_CFA_register);
1363 out_uleb128 (insn->u.rr.reg1);
1364 out_uleb128 (insn->u.rr.reg2);
1367 case DW_CFA_remember_state:
1368 case DW_CFA_restore_state:
1369 out_one (insn->insn);
1372 case DW_CFA_GNU_window_save:
1373 out_one (DW_CFA_GNU_window_save);
1378 struct cfi_escape_data *e;
1379 for (e = insn->u.esc; e ; e = e->next)
1380 emit_expr (&e->exp, 1);
1384 case CFI_val_encoded_addr:
1386 unsigned encoding = insn->u.ea.encoding;
1387 offsetT encoding_size;
1389 if (encoding == DW_EH_PE_omit)
1391 out_one (DW_CFA_val_expression);
1392 out_uleb128 (insn->u.ea.reg);
1394 switch (encoding & 0x7)
1396 case DW_EH_PE_absptr:
1397 encoding_size = DWARF2_ADDR_SIZE (stdoutput);
1399 case DW_EH_PE_udata2:
1402 case DW_EH_PE_udata4:
1405 case DW_EH_PE_udata8:
1412 /* If the user has requested absolute encoding,
1413 then use the smaller DW_OP_addr encoding. */
1414 if (insn->u.ea.encoding == DW_EH_PE_absptr)
1416 out_uleb128 (1 + encoding_size);
1417 out_one (DW_OP_addr);
1421 out_uleb128 (1 + 1 + encoding_size);
1422 out_one (DW_OP_GNU_encoded_addr);
1425 if ((encoding & 0x70) == DW_EH_PE_pcrel)
1427 #if CFI_DIFF_EXPR_OK
1428 insn->u.ea.exp.X_op = O_subtract;
1429 insn->u.ea.exp.X_op_symbol = symbol_temp_new_now ();
1430 #elif defined (tc_cfi_emit_pcrel_expr)
1431 tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size);
1438 emit_expr (&insn->u.ea.exp, encoding_size);
1448 encoding_size (unsigned char encoding)
1450 if (encoding == DW_EH_PE_omit)
1452 switch (encoding & 0x7)
1455 return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4;
1456 case DW_EH_PE_udata2:
1458 case DW_EH_PE_udata4:
1460 case DW_EH_PE_udata8:
1468 output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align)
1470 symbolS *after_size_address, *end_address;
1472 struct cfi_insn_data *i;
1473 offsetT augmentation_size;
1475 enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1477 cie->start_address = symbol_temp_new_now ();
1478 after_size_address = symbol_temp_make ();
1479 end_address = symbol_temp_make ();
1481 exp.X_op = O_subtract;
1482 exp.X_add_symbol = end_address;
1483 exp.X_op_symbol = after_size_address;
1484 exp.X_add_number = 0;
1486 if (eh_frame || fmt == dwarf2_format_32bit)
1487 emit_expr (&exp, 4); /* Length. */
1490 if (fmt == dwarf2_format_64bit)
1492 emit_expr (&exp, 8); /* Length. */
1494 symbol_set_value_now (after_size_address);
1496 out_four (0); /* CIE id. */
1499 out_four (-1); /* CIE id. */
1500 if (fmt != dwarf2_format_32bit)
1503 out_one (DW_CIE_VERSION); /* Version. */
1506 out_one ('z'); /* Augmentation. */
1507 if (cie->per_encoding != DW_EH_PE_omit)
1509 if (cie->lsda_encoding != DW_EH_PE_omit)
1513 if (cie->signal_frame)
1516 out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */
1517 out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */
1518 if (DW_CIE_VERSION == 1) /* Return column. */
1519 out_one (cie->return_column);
1521 out_uleb128 (cie->return_column);
1524 augmentation_size = 1 + (cie->lsda_encoding != DW_EH_PE_omit);
1525 if (cie->per_encoding != DW_EH_PE_omit)
1526 augmentation_size += 1 + encoding_size (cie->per_encoding);
1527 out_uleb128 (augmentation_size); /* Augmentation size. */
1529 if (cie->per_encoding != DW_EH_PE_omit)
1531 offsetT size = encoding_size (cie->per_encoding);
1532 out_one (cie->per_encoding);
1533 exp = cie->personality;
1534 if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel)
1536 #if CFI_DIFF_EXPR_OK
1537 exp.X_op = O_subtract;
1538 exp.X_op_symbol = symbol_temp_new_now ();
1539 emit_expr (&exp, size);
1540 #elif defined (tc_cfi_emit_pcrel_expr)
1541 tc_cfi_emit_pcrel_expr (&exp, size);
1547 emit_expr (&exp, size);
1550 if (cie->lsda_encoding != DW_EH_PE_omit)
1551 out_one (cie->lsda_encoding);
1554 switch (DWARF2_FDE_RELOC_SIZE)
1557 enc = DW_EH_PE_sdata2;
1560 enc = DW_EH_PE_sdata4;
1563 enc = DW_EH_PE_sdata8;
1568 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr
1569 enc |= DW_EH_PE_pcrel;
1576 for (i = cie->first; i != cie->last; i = i->next)
1578 if (CUR_SEG (i) != CUR_SEG (cie))
1580 output_cfi_insn (i);
1584 frag_align (align, DW_CFA_nop, 0);
1585 symbol_set_value_now (end_address);
1589 output_fde (struct fde_entry *fde, struct cie_entry *cie,
1590 bfd_boolean eh_frame, struct cfi_insn_data *first,
1593 symbolS *after_size_address, *end_address;
1595 offsetT augmentation_size;
1596 enum dwarf2_format fmt = DWARF2_FORMAT (now_seg);
1600 after_size_address = symbol_temp_make ();
1601 end_address = symbol_temp_make ();
1603 exp.X_op = O_subtract;
1604 exp.X_add_symbol = end_address;
1605 exp.X_op_symbol = after_size_address;
1606 exp.X_add_number = 0;
1607 if (eh_frame || fmt == dwarf2_format_32bit)
1611 if (fmt == dwarf2_format_64bit)
1615 emit_expr (&exp, offset_size); /* Length. */
1616 symbol_set_value_now (after_size_address);
1620 exp.X_op = O_subtract;
1621 exp.X_add_symbol = after_size_address;
1622 exp.X_op_symbol = cie->start_address;
1623 exp.X_add_number = 0;
1624 emit_expr (&exp, offset_size); /* CIE offset. */
1628 TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size);
1633 exp.X_op = O_subtract;
1634 exp.X_add_number = 0;
1635 #if CFI_DIFF_EXPR_OK
1636 exp.X_add_symbol = fde->start_address;
1637 exp.X_op_symbol = symbol_temp_new_now ();
1638 emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */
1640 exp.X_op = O_symbol;
1641 exp.X_add_symbol = fde->start_address;
1642 #ifdef tc_cfi_emit_pcrel_expr
1643 tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */
1645 emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */
1648 addr_size = DWARF2_FDE_RELOC_SIZE;
1652 exp.X_op = O_symbol;
1653 exp.X_add_symbol = fde->start_address;
1654 exp.X_add_number = 0;
1655 addr_size = DWARF2_ADDR_SIZE (stdoutput);
1656 emit_expr (&exp, addr_size);
1659 exp.X_op = O_subtract;
1660 exp.X_add_symbol = fde->end_address;
1661 exp.X_op_symbol = fde->start_address; /* Code length. */
1662 exp.X_add_number = 0;
1663 emit_expr (&exp, addr_size);
1665 augmentation_size = encoding_size (fde->lsda_encoding);
1667 out_uleb128 (augmentation_size); /* Augmentation size. */
1669 if (fde->lsda_encoding != DW_EH_PE_omit)
1672 if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel)
1674 #if CFI_DIFF_LSDA_OK
1675 exp.X_op = O_subtract;
1676 exp.X_op_symbol = symbol_temp_new_now ();
1677 emit_expr (&exp, augmentation_size);
1678 #elif defined (tc_cfi_emit_pcrel_expr)
1679 tc_cfi_emit_pcrel_expr (&exp, augmentation_size);
1685 emit_expr (&exp, augmentation_size);
1688 for (; first; first = first->next)
1689 if (CUR_SEG (first) == CUR_SEG (fde))
1690 output_cfi_insn (first);
1692 frag_align (align, DW_CFA_nop, 0);
1693 symbol_set_value_now (end_address);
1696 static struct cie_entry *
1697 select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame,
1698 struct cfi_insn_data **pfirst, int align)
1700 struct cfi_insn_data *i, *j;
1701 struct cie_entry *cie;
1703 for (cie = cie_root; cie; cie = cie->next)
1705 if (CUR_SEG (cie) != CUR_SEG (fde))
1707 if (cie->return_column != fde->return_column
1708 || cie->signal_frame != fde->signal_frame
1709 || cie->per_encoding != fde->per_encoding
1710 || cie->lsda_encoding != fde->lsda_encoding)
1712 if (cie->per_encoding != DW_EH_PE_omit)
1714 if (cie->personality.X_op != fde->personality.X_op
1715 || cie->personality.X_add_number
1716 != fde->personality.X_add_number)
1718 switch (cie->personality.X_op)
1721 if (cie->personality.X_unsigned != fde->personality.X_unsigned)
1725 if (cie->personality.X_add_symbol
1726 != fde->personality.X_add_symbol)
1733 for (i = cie->first, j = fde->data;
1734 i != cie->last && j != NULL;
1735 i = i->next, j = j->next)
1737 if (i->insn != j->insn)
1741 case DW_CFA_advance_loc:
1742 case DW_CFA_remember_state:
1743 /* We reached the first advance/remember in the FDE,
1744 but did not reach the end of the CIE list. */
1748 case DW_CFA_def_cfa:
1749 if (i->u.ri.reg != j->u.ri.reg)
1751 if (i->u.ri.offset != j->u.ri.offset)
1755 case DW_CFA_register:
1756 if (i->u.rr.reg1 != j->u.rr.reg1)
1758 if (i->u.rr.reg2 != j->u.rr.reg2)
1762 case DW_CFA_def_cfa_register:
1763 case DW_CFA_restore:
1764 case DW_CFA_undefined:
1765 case DW_CFA_same_value:
1766 if (i->u.r != j->u.r)
1770 case DW_CFA_def_cfa_offset:
1771 if (i->u.i != j->u.i)
1776 case CFI_val_encoded_addr:
1777 /* Don't bother matching these for now. */
1785 /* Success if we reached the end of the CIE list, and we've either
1786 run out of FDE entries or we've encountered an advance,
1787 remember, or escape. */
1790 || j->insn == DW_CFA_advance_loc
1791 || j->insn == DW_CFA_remember_state
1792 || j->insn == CFI_escape
1793 || j->insn == CFI_val_encoded_addr))
1802 cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
1803 cie->next = cie_root;
1805 SET_CUR_SEG (cie, CUR_SEG (fde));
1806 cie->return_column = fde->return_column;
1807 cie->signal_frame = fde->signal_frame;
1808 cie->per_encoding = fde->per_encoding;
1809 cie->lsda_encoding = fde->lsda_encoding;
1810 cie->personality = fde->personality;
1811 cie->first = fde->data;
1813 for (i = cie->first; i ; i = i->next)
1814 if (i->insn == DW_CFA_advance_loc
1815 || i->insn == DW_CFA_remember_state
1816 || i->insn == CFI_escape
1817 || i->insn == CFI_val_encoded_addr)
1823 output_cie (cie, eh_frame, align);
1828 #ifdef md_reg_eh_frame_to_debug_frame
1830 cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
1832 for (; insn; insn = insn->next)
1834 if (CUR_SEG (insn) != ccseg)
1838 case DW_CFA_advance_loc:
1839 case DW_CFA_def_cfa_offset:
1840 case DW_CFA_remember_state:
1841 case DW_CFA_restore_state:
1842 case DW_CFA_GNU_window_save:
1846 case DW_CFA_def_cfa:
1848 insn->u.ri.reg = md_reg_eh_frame_to_debug_frame (insn->u.ri.reg);
1851 case DW_CFA_def_cfa_register:
1852 case DW_CFA_undefined:
1853 case DW_CFA_same_value:
1854 case DW_CFA_restore:
1855 insn->u.r = md_reg_eh_frame_to_debug_frame (insn->u.r);
1858 case DW_CFA_register:
1859 insn->u.rr.reg1 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg1);
1860 insn->u.rr.reg2 = md_reg_eh_frame_to_debug_frame (insn->u.rr.reg2);
1863 case CFI_val_encoded_addr:
1864 insn->u.ea.reg = md_reg_eh_frame_to_debug_frame (insn->u.ea.reg);
1873 #define cfi_change_reg_numbers(insn, cseg) do { } while (0)
1877 get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
1879 if (SUPPORT_FRAME_LINKONCE)
1881 struct dwcfi_seg_list *l;
1883 l = dwcfi_hash_find_or_make (cseg, base, flags);
1886 subseg_set (cseg, l->subseg);
1890 cseg = subseg_new (base, 0);
1891 bfd_set_section_flags (stdoutput, cseg, flags);
1893 record_alignment (cseg, align);
1900 struct cie_entry *cie, *cie_next;
1901 segT cfi_seg, ccseg;
1902 struct fde_entry *fde;
1903 struct cfi_insn_data *first;
1904 int save_flag_traditional_format, seek_next_seg;
1906 if (all_fde_data == 0)
1909 if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
1911 /* Make sure check_eh_frame doesn't do anything with our output. */
1912 save_flag_traditional_format = flag_traditional_format;
1913 flag_traditional_format = 1;
1915 if (!SUPPORT_FRAME_LINKONCE)
1917 /* Open .eh_frame section. */
1918 cfi_seg = get_cfi_seg (NULL, ".eh_frame",
1919 (SEC_ALLOC | SEC_LOAD | SEC_DATA
1920 | DWARF2_EH_FRAME_READ_ONLY),
1921 EH_FRAME_ALIGNMENT);
1922 #ifdef md_fix_up_eh_frame
1923 md_fix_up_eh_frame (cfi_seg);
1934 for (cie = cie_root; cie; cie = cie_next)
1936 cie_next = cie->next;
1937 free ((void *) cie);
1941 for (fde = all_fde_data; fde ; fde = fde->next)
1943 if (SUPPORT_FRAME_LINKONCE)
1947 if (seek_next_seg && CUR_SEG (fde) != ccseg)
1954 ccseg = CUR_SEG (fde);
1955 /* Open .eh_frame section. */
1956 cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
1957 (SEC_ALLOC | SEC_LOAD | SEC_DATA
1958 | DWARF2_EH_FRAME_READ_ONLY),
1959 EH_FRAME_ALIGNMENT);
1960 #ifdef md_fix_up_eh_frame
1961 md_fix_up_eh_frame (cfi_seg);
1967 SET_HANDLED (fde, 1);
1970 if (fde->end_address == NULL)
1972 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
1973 fde->end_address = fde->start_address;
1976 cie = select_cie_for_fde (fde, TRUE, &first, 2);
1977 output_fde (fde, cie, TRUE, first,
1978 fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
1981 while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
1983 if (SUPPORT_FRAME_LINKONCE)
1984 for (fde = all_fde_data; fde ; fde = fde->next)
1985 SET_HANDLED (fde, 0);
1987 flag_traditional_format = save_flag_traditional_format;
1990 if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
1992 int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
1994 if (!SUPPORT_FRAME_LINKONCE)
1995 get_cfi_seg (NULL, ".debug_frame",
1996 SEC_READONLY | SEC_DEBUGGING,
2004 for (cie = cie_root; cie; cie = cie_next)
2006 cie_next = cie->next;
2007 free ((void *) cie);
2011 for (fde = all_fde_data; fde ; fde = fde->next)
2013 if (SUPPORT_FRAME_LINKONCE)
2017 if (seek_next_seg && CUR_SEG (fde) != ccseg)
2024 ccseg = CUR_SEG (fde);
2025 /* Open .debug_frame section. */
2026 get_cfi_seg (ccseg, ".debug_frame",
2027 SEC_READONLY | SEC_DEBUGGING,
2031 SET_HANDLED (fde, 1);
2033 if (fde->end_address == NULL)
2035 as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
2036 fde->end_address = fde->start_address;
2039 fde->per_encoding = DW_EH_PE_omit;
2040 fde->lsda_encoding = DW_EH_PE_omit;
2041 cfi_change_reg_numbers (fde->data, ccseg);
2042 cie = select_cie_for_fde (fde, FALSE, &first, alignment);
2043 output_fde (fde, cie, FALSE, first, alignment);
2046 while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2);
2048 if (SUPPORT_FRAME_LINKONCE)
2049 for (fde = all_fde_data; fde ; fde = fde->next)
2050 SET_HANDLED (fde, 0);
2054 #else /* TARGET_USE_CFIPOP */
2056 /* Emit an intelligible error message for missing support. */
2059 dot_cfi_dummy (int ignored ATTRIBUTE_UNUSED)
2061 as_bad (_("CFI is not supported for this target"));
2062 ignore_rest_of_line ();
2065 const pseudo_typeS cfi_pseudo_table[] =
2067 { "cfi_sections", dot_cfi_dummy, 0 },
2068 { "cfi_startproc", dot_cfi_dummy, 0 },
2069 { "cfi_endproc", dot_cfi_dummy, 0 },
2070 { "cfi_def_cfa", dot_cfi_dummy, 0 },
2071 { "cfi_def_cfa_register", dot_cfi_dummy, 0 },
2072 { "cfi_def_cfa_offset", dot_cfi_dummy, 0 },
2073 { "cfi_adjust_cfa_offset", dot_cfi_dummy, 0 },
2074 { "cfi_offset", dot_cfi_dummy, 0 },
2075 { "cfi_rel_offset", dot_cfi_dummy, 0 },
2076 { "cfi_register", dot_cfi_dummy, 0 },
2077 { "cfi_return_column", dot_cfi_dummy, 0 },
2078 { "cfi_restore", dot_cfi_dummy, 0 },
2079 { "cfi_undefined", dot_cfi_dummy, 0 },
2080 { "cfi_same_value", dot_cfi_dummy, 0 },
2081 { "cfi_remember_state", dot_cfi_dummy, 0 },
2082 { "cfi_restore_state", dot_cfi_dummy, 0 },
2083 { "cfi_window_save", dot_cfi_dummy, 0 },
2084 { "cfi_escape", dot_cfi_dummy, 0 },
2085 { "cfi_signal_frame", dot_cfi_dummy, 0 },
2086 { "cfi_personality", dot_cfi_dummy, 0 },
2087 { "cfi_lsda", dot_cfi_dummy, 0 },
2088 { "cfi_val_encoded_addr", dot_cfi_dummy, 0 },
2096 #endif /* TARGET_USE_CFIPOP */