X-Git-Url: http://git.efficios.com/?a=blobdiff_plain;f=gas%2Fdw2gencfi.c;h=a4fe8ac9196099f8049e3b650b8ea9744e1f1bb7;hb=refs%2Fheads%2Fconcurrent-displaced-stepping-2020-04-01;hp=ef97e18134038501f07f1a01e646897fc2ecebd0;hpb=73e7610887dfd4313b66f33436bc18570d58b2ac;p=deliverable%2Fbinutils-gdb.git diff --git a/gas/dw2gencfi.c b/gas/dw2gencfi.c index ef97e18134..a4fe8ac919 100644 --- a/gas/dw2gencfi.c +++ b/gas/dw2gencfi.c @@ -1,5 +1,5 @@ /* dw2gencfi.c - Support for generating Dwarf2 CFI information. - Copyright (C) 2003-2015 Free Software Foundation, Inc. + Copyright (C) 2003-2020 Free Software Foundation, Inc. Contributed by Michal Ludvig This file is part of GAS, the GNU Assembler. @@ -75,6 +75,8 @@ # define tc_cfi_endproc(fde) ((void) (fde)) #endif +#define EH_FRAME_LINKONCE (SUPPORT_FRAME_LINKONCE || compact_eh) + #ifndef DWARF2_FORMAT #define DWARF2_FORMAT(SEC) dwarf2_format_32bit #endif @@ -83,7 +85,7 @@ #define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8) #endif -#if SUPPORT_FRAME_LINKONCE +#if MULTIPLE_FRAME_SECTIONS #define CUR_SEG(structp) structp->cur_seg #define SET_CUR_SEG(structp, seg) structp->cur_seg = seg #define HANDLED(structp) structp->handled @@ -95,6 +97,10 @@ #define SET_HANDLED(structp, val) (void) (0 && val) #endif +#ifndef tc_cfi_reloc_for_encoding +#define tc_cfi_reloc_for_encoding(e) BFD_RELOC_NONE +#endif + /* Private segment collection list. */ struct dwcfi_seg_list { @@ -103,41 +109,153 @@ struct dwcfi_seg_list char * seg_name; }; -#define FRAME_NAME ".eh_frame" +#ifdef SUPPORT_COMPACT_EH +static bfd_boolean compact_eh; +#else +#define compact_eh 0 +#endif static struct hash_control *dwcfi_hash; + +/* Emit a single byte into the current segment. */ + +static inline void +out_one (int byte) +{ + FRAG_APPEND_1_CHAR (byte); +} + +/* Emit a two-byte word into the current segment. */ + +static inline void +out_two (int data) +{ + md_number_to_chars (frag_more (2), data, 2); +} + +/* Emit a four byte word into the current segment. */ + +static inline void +out_four (int data) +{ + md_number_to_chars (frag_more (4), data, 4); +} + +/* Emit an unsigned "little-endian base 128" number. */ + +static void +out_uleb128 (addressT value) +{ + output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); +} + +/* Emit an unsigned "little-endian base 128" number. */ + +static void +out_sleb128 (offsetT value) +{ + output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); +} +static unsigned int +encoding_size (unsigned char encoding) +{ + if (encoding == DW_EH_PE_omit) + return 0; + switch (encoding & 0x7) + { + case 0: + return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4; + case DW_EH_PE_udata2: + return 2; + case DW_EH_PE_udata4: + return 4; + case DW_EH_PE_udata8: + return 8; + default: + abort (); + } +} + +/* Emit expression EXP in ENCODING. If EMIT_ENCODING is true, first + emit a byte containing ENCODING. */ + +static void +emit_expr_encoded (expressionS *exp, int encoding, bfd_boolean emit_encoding) +{ + unsigned int size = encoding_size (encoding); + bfd_reloc_code_real_type code; + + if (encoding == DW_EH_PE_omit) + return; + + if (emit_encoding) + out_one (encoding); + + code = tc_cfi_reloc_for_encoding (encoding); + if (code != BFD_RELOC_NONE) + { + reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code); + char *p = frag_more (size); + gas_assert (size == (unsigned) howto->bitsize / 8); + md_number_to_chars (p, 0, size); + fix_new (frag_now, p - frag_now->fr_literal, size, exp->X_add_symbol, + exp->X_add_number, howto->pc_relative, code); + } + else if ((encoding & 0x70) == DW_EH_PE_pcrel) + { +#if CFI_DIFF_EXPR_OK + expressionS tmp = *exp; + tmp.X_op = O_subtract; + tmp.X_op_symbol = symbol_temp_new_now (); + emit_expr (&tmp, size); +#elif defined (tc_cfi_emit_pcrel_expr) + tc_cfi_emit_pcrel_expr (exp, size); +#else + abort (); +#endif + } + else + emit_expr (exp, size); +} + /* Build based on segment the derived .debug_... segment name containing origin segment's postfix name part. */ static char * get_debugseg_name (segT seg, const char *base_name) { - const char *name; + const char * name; + const char * dollar; + const char * dot; if (!seg) - name = ""; - else - { - const char * dollar; - const char * dot; + return concat (base_name, NULL); - name = bfd_get_section_name (stdoutput, seg); + name = bfd_section_name (seg); - dollar = strchr (name, '$'); - dot = strchr (name + 1, '.'); + if (name == NULL || *name == 0) + return concat (base_name, NULL); + + dollar = strchr (name, '$'); + dot = strchr (name + 1, '.'); - if (!dollar && !dot) - name = ""; - else if (!dollar) - name = dot; - else if (!dot) - name = dollar; - else if (dot < dollar) - name = dot; - else - name = dollar; + if (!dollar && !dot) + { + if (!strcmp (base_name, ".eh_frame_entry") + && strcmp (name, ".text") != 0) + return concat (base_name, ".", name, NULL); + + name = ""; } + else if (!dollar) + name = dot; + else if (!dot) + name = dollar; + else if (dot < dollar) + name = dot; + else + name = dollar; return concat (base_name, name, NULL); } @@ -160,7 +278,10 @@ alloc_debugseg_item (segT seg, int subseg, char *name) static segT is_now_linkonce_segment (void) { - if ((bfd_get_section_flags (stdoutput, now_seg) + if (compact_eh) + return now_seg; + + if ((bfd_section_flags (now_seg) & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE | SEC_LINK_DUPLICATES_SAME_CONTENTS)) != 0) @@ -185,16 +306,16 @@ make_debug_seg (segT cseg, char *name, int sflags) if (!cseg) flags = 0; else - flags = bfd_get_section_flags (stdoutput, cseg) - & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD - | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE - | SEC_LINK_DUPLICATES_SAME_CONTENTS); + flags = (bfd_section_flags (cseg) + & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD + | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE + | SEC_LINK_DUPLICATES_SAME_CONTENTS)); /* Add standard section flags. */ flags |= sflags; /* Apply possibly linked once flags to new generated segment, too. */ - if (!bfd_set_section_flags (stdoutput, r, flags)) + if (!bfd_set_section_flags (r, flags)) as_bad (_("bfd_set_section_flags: %s"), bfd_errmsg (bfd_get_error ())); @@ -272,15 +393,19 @@ struct cfi_escape_data struct cie_entry { struct cie_entry *next; -#if SUPPORT_FRAME_LINKONCE +#if MULTIPLE_FRAME_SECTIONS segT cur_seg; #endif symbolS *start_address; unsigned int return_column; unsigned int signal_frame; + unsigned char fde_encoding; unsigned char per_encoding; unsigned char lsda_encoding; expressionS personality; +#ifdef tc_cie_entry_extras + tc_cie_entry_extras +#endif struct cfi_insn_data *first, *last; }; @@ -292,32 +417,14 @@ static struct fde_entry **last_fde_data = &all_fde_data; /* List of CIEs so that they could be reused. */ static struct cie_entry *cie_root; -/* Stack of old CFI data, for save/restore. */ -struct cfa_save_data -{ - struct cfa_save_data *next; - offsetT cfa_offset; -}; - -/* Current open FDE entry. */ -struct frch_cfi_data -{ - struct fde_entry *cur_fde_data; - symbolS *last_address; - offsetT cur_cfa_offset; - struct cfa_save_data *cfa_save_stack; -}; - /* Construct a new FDE structure and add it to the end of the fde list. */ static struct fde_entry * alloc_fde_entry (void) { - struct fde_entry *fde = (struct fde_entry *) - xcalloc (1, sizeof (struct fde_entry)); + struct fde_entry *fde = XCNEW (struct fde_entry); - frchain_now->frch_cfi_data = (struct frch_cfi_data *) - xcalloc (1, sizeof (struct frch_cfi_data)); + frchain_now->frch_cfi_data = XCNEW (struct frch_cfi_data); frchain_now->frch_cfi_data->cur_fde_data = fde; *last_fde_data = fde; last_fde_data = &fde->next; @@ -327,6 +434,10 @@ alloc_fde_entry (void) fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN; fde->per_encoding = DW_EH_PE_omit; fde->lsda_encoding = DW_EH_PE_omit; + fde->eh_header_type = EH_COMPACT_UNKNOWN; +#ifdef tc_fde_entry_init_extra + tc_fde_entry_init_extra (fde) +#endif return fde; } @@ -337,11 +448,15 @@ alloc_fde_entry (void) /* Construct a new INSN structure and add it to the end of the insn list for the currently active FDE. */ +static bfd_boolean cfi_sections_set = FALSE; +static int cfi_sections = CFI_EMIT_eh_frame; +int all_cfi_sections = 0; +static struct fde_entry *last_fde; + static struct cfi_insn_data * alloc_cfi_insn_data (void) { - struct cfi_insn_data *insn = (struct cfi_insn_data *) - xcalloc (1, sizeof (struct cfi_insn_data)); + struct cfi_insn_data *insn = XCNEW (struct cfi_insn_data); struct fde_entry *cur_fde_data = frchain_now->frch_cfi_data->cur_fde_data; *cur_fde_data->last = insn; @@ -378,6 +493,13 @@ cfi_set_return_column (unsigned regno) frchain_now->frch_cfi_data->cur_fde_data->return_column = regno; } +void +cfi_set_sections (void) +{ + frchain_now->frch_cfi_data->cur_fde_data->sections = all_cfi_sections; + cfi_sections_set = TRUE; +} + /* Universal functions to store new instructions. */ static void @@ -469,6 +591,22 @@ cfi_add_CFA_offset (unsigned regno, offsetT offset) as_bad (_("register save offset not a multiple of %u"), abs_data_align); } +/* Add a DW_CFA_val_offset record to the CFI data. */ + +void +cfi_add_CFA_val_offset (unsigned regno, offsetT offset) +{ + unsigned int abs_data_align; + + gas_assert (DWARF2_CIE_DATA_ALIGNMENT != 0); + cfi_add_CFA_insn_reg_offset (DW_CFA_val_offset, regno, offset); + + abs_data_align = (DWARF2_CIE_DATA_ALIGNMENT < 0 + ? -DWARF2_CIE_DATA_ALIGNMENT : DWARF2_CIE_DATA_ALIGNMENT); + if (offset % abs_data_align) + as_bad (_("register save offset not a multiple of %u"), abs_data_align); +} + /* Add a DW_CFA_def_cfa record to the CFI data. */ void @@ -528,7 +666,7 @@ cfi_add_CFA_remember_state (void) cfi_add_CFA_insn (DW_CFA_remember_state); - p = (struct cfa_save_data *) xmalloc (sizeof (*p)); + p = XNEW (struct cfa_save_data); p->cfa_offset = frchain_now->frch_cfi_data->cur_cfa_offset; p->next = frchain_now->frch_cfi_data->cfa_save_stack; frchain_now->frch_cfi_data->cfa_save_stack = p; @@ -560,9 +698,12 @@ static void dot_cfi_escape (int); static void dot_cfi_sections (int); static void dot_cfi_startproc (int); static void dot_cfi_endproc (int); +static void dot_cfi_fde_data (int); static void dot_cfi_personality (int); +static void dot_cfi_personality_id (int); static void dot_cfi_lsda (int); static void dot_cfi_val_encoded_addr (int); +static void dot_cfi_inline_lsda (int); static void dot_cfi_label (int); const pseudo_typeS cfi_pseudo_table[] = @@ -570,6 +711,7 @@ const pseudo_typeS cfi_pseudo_table[] = { "cfi_sections", dot_cfi_sections, 0 }, { "cfi_startproc", dot_cfi_startproc, 0 }, { "cfi_endproc", dot_cfi_endproc, 0 }, + { "cfi_fde_data", dot_cfi_fde_data, 0 }, { "cfi_def_cfa", dot_cfi, DW_CFA_def_cfa }, { "cfi_def_cfa_register", dot_cfi, DW_CFA_def_cfa_register }, { "cfi_def_cfa_offset", dot_cfi, DW_CFA_def_cfa_offset }, @@ -584,12 +726,16 @@ const pseudo_typeS cfi_pseudo_table[] = { "cfi_remember_state", dot_cfi, DW_CFA_remember_state }, { "cfi_restore_state", dot_cfi, DW_CFA_restore_state }, { "cfi_window_save", dot_cfi, DW_CFA_GNU_window_save }, + { "cfi_negate_ra_state", dot_cfi, DW_CFA_AARCH64_negate_ra_state }, { "cfi_escape", dot_cfi_escape, 0 }, { "cfi_signal_frame", dot_cfi, CFI_signal_frame }, { "cfi_personality", dot_cfi_personality, 0 }, + { "cfi_personality_id", dot_cfi_personality_id, 0 }, { "cfi_lsda", dot_cfi_lsda, 0 }, { "cfi_val_encoded_addr", dot_cfi_val_encoded_addr, 0 }, + { "cfi_inline_lsda", dot_cfi_inline_lsda, 0 }, { "cfi_label", dot_cfi_label, 0 }, + { "cfi_val_offset", dot_cfi, DW_CFA_val_offset }, { NULL, NULL, 0 } }; @@ -615,13 +761,12 @@ tc_parse_to_dw2regnum (expressionS *exp) { char *name, c; - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (& name); exp->X_op = O_constant; exp->X_add_number = tc_regname_to_dw2regnum (name); - *input_line_pointer = c; + restore_line_pointer (c); } else # endif @@ -678,8 +823,8 @@ dot_cfi (int arg) /* If the last address was not at the current PC, advance to current. */ if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now - || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) - != frag_now_fix ()) + || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address) + != frag_now_fix ())) cfi_add_advance_loc (symbol_temp_new_now ()); switch (arg) @@ -691,6 +836,13 @@ dot_cfi (int arg) cfi_add_CFA_offset (reg1, offset); break; + case DW_CFA_val_offset: + reg1 = cfi_parse_reg (); + cfi_parse_separator (); + offset = cfi_parse_const (); + cfi_add_CFA_val_offset (reg1, offset); + break; + case CFI_rel_offset: reg1 = cfi_parse_reg (); cfi_parse_separator (); @@ -801,14 +953,14 @@ dot_cfi_escape (int ignored ATTRIBUTE_UNUSED) /* If the last address was not at the current PC, advance to current. */ if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now - || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) - != frag_now_fix ()) + || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address) + != frag_now_fix ())) cfi_add_advance_loc (symbol_temp_new_now ()); tail = &head; do { - e = (struct cfi_escape_data *) xmalloc (sizeof (*e)); + e = XNEW (struct cfi_escape_data); do_parse_cons_expression (&e->exp, 1); *tail = e; tail = &e->next; @@ -847,14 +999,15 @@ dot_cfi_personality (int ignored ATTRIBUTE_UNUSED) } if ((encoding & 0xff) != encoding - || ((encoding & 0x70) != 0 + || ((((encoding & 0x70) != 0 #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr - && (encoding & 0x70) != DW_EH_PE_pcrel + && (encoding & 0x70) != DW_EH_PE_pcrel #endif - ) - /* leb128 can be handled, but does something actually need it? */ - || (encoding & 7) == DW_EH_PE_uleb128 - || (encoding & 7) > DW_EH_PE_udata8) + ) + /* leb128 can be handled, but does something actually need it? */ + || (encoding & 7) == DW_EH_PE_uleb128 + || (encoding & 7) > DW_EH_PE_udata8) + && tc_cfi_reloc_for_encoding (encoding) == BFD_RELOC_NONE)) { as_bad (_("invalid or unsupported encoding in .cfi_personality")); ignore_rest_of_line (); @@ -917,14 +1070,15 @@ dot_cfi_lsda (int ignored ATTRIBUTE_UNUSED) } if ((encoding & 0xff) != encoding - || ((encoding & 0x70) != 0 + || ((((encoding & 0x70) != 0 #if CFI_DIFF_LSDA_OK || defined tc_cfi_emit_pcrel_expr - && (encoding & 0x70) != DW_EH_PE_pcrel + && (encoding & 0x70) != DW_EH_PE_pcrel #endif - ) - /* leb128 can be handled, but does something actually need it? */ - || (encoding & 7) == DW_EH_PE_uleb128 - || (encoding & 7) > DW_EH_PE_udata8) + ) + /* leb128 can be handled, but does something actually need it? */ + || (encoding & 7) == DW_EH_PE_uleb128 + || (encoding & 7) > DW_EH_PE_udata8) + && tc_cfi_reloc_for_encoding (encoding) == BFD_RELOC_NONE)) { as_bad (_("invalid or unsupported encoding in .cfi_lsda")); ignore_rest_of_line (); @@ -981,8 +1135,8 @@ dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED) /* If the last address was not at the current PC, advance to current. */ if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now - || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) - != frag_now_fix ()) + || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address) + != frag_now_fix ())) cfi_add_advance_loc (symbol_temp_new_now ()); insn_ptr = alloc_cfi_insn_data (); @@ -998,7 +1152,7 @@ dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED) && (encoding & 0x70) != DW_EH_PE_pcrel #endif ) - /* leb128 can be handled, but does something actually need it? */ + /* leb128 can be handled, but does something actually need it? */ || (encoding & 7) == DW_EH_PE_uleb128 || (encoding & 7) > DW_EH_PE_udata8) { @@ -1015,6 +1169,7 @@ dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED) case O_constant: if ((encoding & 0x70) != DW_EH_PE_pcrel) break; + /* Fall through. */ default: encoding = DW_EH_PE_omit; break; @@ -1034,47 +1189,59 @@ dot_cfi_val_encoded_addr (int ignored ATTRIBUTE_UNUSED) static void dot_cfi_label (int ignored ATTRIBUTE_UNUSED) { - char *name = read_symbol_name (); + char *name; + + if (frchain_now->frch_cfi_data == NULL) + { + as_bad (_("CFI instruction used without previous .cfi_startproc")); + ignore_rest_of_line (); + return; + } + name = read_symbol_name (); if (name == NULL) return; /* If the last address was not at the current PC, advance to current. */ if (symbol_get_frag (frchain_now->frch_cfi_data->last_address) != frag_now - || S_GET_VALUE (frchain_now->frch_cfi_data->last_address) - != frag_now_fix ()) + || (S_GET_VALUE (frchain_now->frch_cfi_data->last_address) + != frag_now_fix ())) cfi_add_advance_loc (symbol_temp_new_now ()); cfi_add_label (name); + free (name); demand_empty_rest_of_line (); } -/* By default emit .eh_frame only, not .debug_frame. */ -#define CFI_EMIT_eh_frame (1 << 0) -#define CFI_EMIT_debug_frame (1 << 1) -#define CFI_EMIT_target (1 << 2) -static int cfi_sections = CFI_EMIT_eh_frame; - static void dot_cfi_sections (int ignored ATTRIBUTE_UNUSED) { int sections = 0; SKIP_WHITESPACE (); - if (is_name_beginner (*input_line_pointer)) + if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"') while (1) { + char * saved_ilp; char *name, c; - name = input_line_pointer; - c = get_symbol_end (); + saved_ilp = input_line_pointer; + c = get_symbol_name (& name); if (strncmp (name, ".eh_frame", sizeof ".eh_frame") == 0 && name[9] != '_') sections |= CFI_EMIT_eh_frame; else if (strncmp (name, ".debug_frame", sizeof ".debug_frame") == 0) sections |= CFI_EMIT_debug_frame; +#if SUPPORT_COMPACT_EH + else if (strncmp (name, ".eh_frame_entry", + sizeof ".eh_frame_entry") == 0) + { + compact_eh = TRUE; + sections |= CFI_EMIT_eh_frame_compact; + } +#endif #ifdef tc_cfi_section_name else if (strcmp (name, tc_cfi_section_name) == 0) sections |= CFI_EMIT_target; @@ -1082,27 +1249,34 @@ dot_cfi_sections (int ignored ATTRIBUTE_UNUSED) else { *input_line_pointer = c; - input_line_pointer = name; + input_line_pointer = saved_ilp; break; } *input_line_pointer = c; - SKIP_WHITESPACE (); + SKIP_WHITESPACE_AFTER_NAME (); if (*input_line_pointer == ',') { name = input_line_pointer++; SKIP_WHITESPACE (); - if (!is_name_beginner (*input_line_pointer)) + if (!is_name_beginner (*input_line_pointer) + && *input_line_pointer != '"') { input_line_pointer = name; break; } } - else if (is_name_beginner (*input_line_pointer)) + else if (is_name_beginner (*input_line_pointer) + || *input_line_pointer == '"') break; } demand_empty_rest_of_line (); + if (cfi_sections_set + && (sections & (CFI_EMIT_eh_frame | CFI_EMIT_eh_frame_compact)) + && ((cfi_sections & (CFI_EMIT_eh_frame | CFI_EMIT_eh_frame_compact)) + != (sections & (CFI_EMIT_eh_frame | CFI_EMIT_eh_frame_compact)))) + as_bad (_("inconsistent uses of .cfi_sections")); cfi_sections = sections; } @@ -1121,23 +1295,26 @@ dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED) cfi_new_fde (symbol_temp_new_now ()); SKIP_WHITESPACE (); - if (is_name_beginner (*input_line_pointer)) + if (is_name_beginner (*input_line_pointer) || *input_line_pointer == '"') { + char * saved_ilp = input_line_pointer; char *name, c; - name = input_line_pointer; - c = get_symbol_end (); + c = get_symbol_name (& name); if (strcmp (name, "simple") == 0) { simple = 1; - *input_line_pointer = c; + restore_line_pointer (c); } else - input_line_pointer = name; + input_line_pointer = saved_ilp; } demand_empty_rest_of_line (); + cfi_sections_set = TRUE; + all_cfi_sections |= cfi_sections; + cfi_set_sections (); frchain_now->frch_cfi_data->cur_cfa_offset = 0; if (!simple) tc_cfi_frame_initial_instructions (); @@ -1149,8 +1326,6 @@ dot_cfi_startproc (int ignored ATTRIBUTE_UNUSED) static void dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED) { - struct fde_entry *fde; - if (frchain_now->frch_cfi_data == NULL) { as_bad (_(".cfi_endproc without corresponding .cfi_startproc")); @@ -1158,57 +1333,254 @@ dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED) return; } - fde = frchain_now->frch_cfi_data->cur_fde_data; + last_fde = frchain_now->frch_cfi_data->cur_fde_data; cfi_end_fde (symbol_temp_new_now ()); demand_empty_rest_of_line (); + cfi_sections_set = TRUE; if ((cfi_sections & CFI_EMIT_target) != 0) - tc_cfi_endproc (fde); + tc_cfi_endproc (last_fde); } - -/* Emit a single byte into the current segment. */ - -static inline void -out_one (int byte) +static segT +get_cfi_seg (segT cseg, const char *base, flagword flags, int align) { - FRAG_APPEND_1_CHAR (byte); + /* Exclude .debug_frame sections for Compact EH. */ + if (SUPPORT_FRAME_LINKONCE || ((flags & SEC_DEBUGGING) == 0 && compact_eh)) + { + struct dwcfi_seg_list *l; + + l = dwcfi_hash_find_or_make (cseg, base, flags); + + cseg = l->seg; + subseg_set (cseg, l->subseg); + } + else + { + cseg = subseg_new (base, 0); + bfd_set_section_flags (cseg, flags); + } + record_alignment (cseg, align); + return cseg; } -/* Emit a two-byte word into the current segment. */ +#if SUPPORT_COMPACT_EH +static void +dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED) +{ + struct fde_entry *fde; -static inline void -out_two (int data) + if (frchain_now->frch_cfi_data == NULL) + { + as_bad (_("CFI instruction used without previous .cfi_startproc")); + ignore_rest_of_line (); + return; + } + + fde = frchain_now->frch_cfi_data->cur_fde_data; + fde->personality_id = cfi_parse_const (); + demand_empty_rest_of_line (); + + if (fde->personality_id == 0 || fde->personality_id > 3) + { + as_bad (_("wrong argument to .cfi_personality_id")); + return; + } +} + +static void +dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED) { - md_number_to_chars (frag_more (2), data, 2); + if (frchain_now->frch_cfi_data == NULL) + { + as_bad (_(".cfi_fde_data without corresponding .cfi_startproc")); + ignore_rest_of_line (); + return; + } + + last_fde = frchain_now->frch_cfi_data->cur_fde_data; + + cfi_sections_set = TRUE; + if ((cfi_sections & CFI_EMIT_target) != 0 + || (cfi_sections & CFI_EMIT_eh_frame_compact) != 0) + { + struct cfi_escape_data *head, **tail, *e; + int num_ops = 0; + + tail = &head; + if (!is_it_end_of_statement ()) + { + num_ops = 0; + do + { + e = XNEW (struct cfi_escape_data); + do_parse_cons_expression (&e->exp, 1); + *tail = e; + tail = &e->next; + num_ops++; + } + while (*input_line_pointer++ == ','); + --input_line_pointer; + } + *tail = NULL; + + if (last_fde->lsda_encoding != DW_EH_PE_omit) + last_fde->eh_header_type = EH_COMPACT_HAS_LSDA; + else if (num_ops <= 3 && last_fde->per_encoding == DW_EH_PE_omit) + last_fde->eh_header_type = EH_COMPACT_INLINE; + else + last_fde->eh_header_type = EH_COMPACT_OUTLINE; + + if (last_fde->eh_header_type == EH_COMPACT_INLINE) + num_ops = 3; + + last_fde->eh_data_size = num_ops; + last_fde->eh_data = XNEWVEC (bfd_byte, num_ops); + num_ops = 0; + while (head) + { + e = head; + head = e->next; + last_fde->eh_data[num_ops++] = e->exp.X_add_number; + free (e); + } + if (last_fde->eh_header_type == EH_COMPACT_INLINE) + while (num_ops < 3) + last_fde->eh_data[num_ops++] = tc_compact_eh_opcode_stop; + } + + demand_empty_rest_of_line (); } -/* Emit a four byte word into the current segment. */ +/* Function to emit the compact unwinding opcodes stored in the + fde's eh_data field. The end of the opcode data will be + padded to the value in align. */ -static inline void -out_four (int data) +static void +output_compact_unwind_data (struct fde_entry *fde, int align) { - md_number_to_chars (frag_more (4), data, 4); + int data_size = fde->eh_data_size + 2; + int align_padding; + int amask; + char *p; + + fde->eh_loc = symbol_temp_new_now (); + + p = frag_more (1); + if (fde->personality_id != 0) + *p = fde->personality_id; + else if (fde->per_encoding != DW_EH_PE_omit) + { + *p = 0; + emit_expr_encoded (&fde->personality, fde->per_encoding, FALSE); + data_size += encoding_size (fde->per_encoding); + } + else + *p = 1; + + amask = (1 << align) - 1; + align_padding = ((data_size + amask) & ~amask) - data_size; + + p = frag_more (fde->eh_data_size + 1 + align_padding); + memcpy (p, fde->eh_data, fde->eh_data_size); + p += fde->eh_data_size; + + while (align_padding-- > 0) + *(p++) = tc_compact_eh_opcode_pad; + + *(p++) = tc_compact_eh_opcode_stop; + fde->eh_header_type = EH_COMPACT_OUTLINE_DONE; } -/* Emit an unsigned "little-endian base 128" number. */ +/* Handle the .cfi_inline_lsda directive. */ +static void +dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED) +{ + segT ccseg; + int align; + long max_alignment = 28; + + if (!last_fde) + { + as_bad (_("unexpected .cfi_inline_lsda")); + ignore_rest_of_line (); + return; + } + + if ((last_fde->sections & CFI_EMIT_eh_frame_compact) == 0) + { + as_bad (_(".cfi_inline_lsda not valid for this frame")); + ignore_rest_of_line (); + return; + } + + if (last_fde->eh_header_type != EH_COMPACT_UNKNOWN + && last_fde->eh_header_type != EH_COMPACT_HAS_LSDA) + { + as_bad (_(".cfi_inline_lsda seen for frame without .cfi_lsda")); + ignore_rest_of_line (); + return; + } + +#ifdef md_flush_pending_output + md_flush_pending_output (); +#endif + + align = get_absolute_expression (); + if (align > max_alignment) + { + align = max_alignment; + as_bad (_("Alignment too large: %d. assumed."), align); + } + else if (align < 0) + { + as_warn (_("Alignment negative: 0 assumed.")); + align = 0; + } + + demand_empty_rest_of_line (); + ccseg = CUR_SEG (last_fde); + + /* Open .gnu_extab section. */ + get_cfi_seg (ccseg, ".gnu_extab", + (SEC_ALLOC | SEC_LOAD | SEC_DATA + | DWARF2_EH_FRAME_READ_ONLY), + 1); + + frag_align (align, 0, 0); + record_alignment (now_seg, align); + if (last_fde->eh_header_type == EH_COMPACT_HAS_LSDA) + output_compact_unwind_data (last_fde, align); + + last_fde = NULL; + return; +} +#else /* !SUPPORT_COMPACT_EH */ static void -out_uleb128 (addressT value) +dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED) { - output_leb128 (frag_more (sizeof_leb128 (value, 0)), value, 0); + as_bad (_(".cfi_inline_lsda is not supported for this target")); + ignore_rest_of_line (); } -/* Emit an unsigned "little-endian base 128" number. */ - static void -out_sleb128 (offsetT value) +dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED) { - output_leb128 (frag_more (sizeof_leb128 (value, 1)), value, 1); + as_bad (_(".cfi_fde_data is not supported for this target")); + ignore_rest_of_line (); } +static void +dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED) +{ + as_bad (_(".cfi_personality_id is not supported for this target")); + ignore_rest_of_line (); +} +#endif + static void output_cfi_insn (struct cfi_insn_data *insn) { @@ -1227,7 +1599,9 @@ output_cfi_insn (struct cfi_insn_data *insn) addressT delta = S_GET_VALUE (to) - S_GET_VALUE (from); addressT scaled = delta / DWARF2_LINE_MIN_INSN_LENGTH; - if (scaled <= 0x3F) + if (scaled == 0) + ; + else if (scaled <= 0x3F) out_one (DW_CFA_advance_loc + scaled); else if (scaled <= 0xFF) { @@ -1257,7 +1631,12 @@ output_cfi_insn (struct cfi_insn_data *insn) /* The code in ehopt.c expects that one byte of the encoding is already allocated to the frag. This comes from the way that it scans the .eh_frame section looking first for the - .byte DW_CFA_advance_loc4. */ + .byte DW_CFA_advance_loc4. Call frag_grow with the sum of + room needed by frag_more and frag_var to preallocate space + ensuring that the DW_CFA_advance_loc4 is in the fixed part + of the rs_cfa frag, so that the relax machinery can remove + the advance_loc should it advance by zero. */ + frag_grow (5); *frag_more (1) = DW_CFA_advance_loc4; frag_var (rs_cfa, 4, 0, DWARF2_LINE_MIN_INSN_LENGTH << 3, @@ -1339,6 +1718,23 @@ output_cfi_insn (struct cfi_insn_data *insn) } break; + case DW_CFA_val_offset: + regno = insn->u.ri.reg; + offset = insn->u.ri.offset / DWARF2_CIE_DATA_ALIGNMENT; + if (offset < 0) + { + out_one (DW_CFA_val_offset_sf); + out_uleb128 (regno); + out_sleb128 (offset); + } + else + { + out_one (DW_CFA_val_offset); + out_uleb128 (regno); + out_uleb128 (offset); + } + break; + case DW_CFA_register: out_one (DW_CFA_register); out_uleb128 (insn->u.rr.reg1); @@ -1365,7 +1761,7 @@ output_cfi_insn (struct cfi_insn_data *insn) case CFI_val_encoded_addr: { unsigned encoding = insn->u.ea.encoding; - offsetT encoding_size; + offsetT enc_size; if (encoding == DW_EH_PE_omit) break; @@ -1375,16 +1771,16 @@ output_cfi_insn (struct cfi_insn_data *insn) switch (encoding & 0x7) { case DW_EH_PE_absptr: - encoding_size = DWARF2_ADDR_SIZE (stdoutput); + enc_size = DWARF2_ADDR_SIZE (stdoutput); break; case DW_EH_PE_udata2: - encoding_size = 2; + enc_size = 2; break; case DW_EH_PE_udata4: - encoding_size = 4; + enc_size = 4; break; case DW_EH_PE_udata8: - encoding_size = 8; + enc_size = 8; break; default: abort (); @@ -1394,12 +1790,12 @@ output_cfi_insn (struct cfi_insn_data *insn) then use the smaller DW_OP_addr encoding. */ if (insn->u.ea.encoding == DW_EH_PE_absptr) { - out_uleb128 (1 + encoding_size); + out_uleb128 (1 + enc_size); out_one (DW_OP_addr); } else { - out_uleb128 (1 + 1 + encoding_size); + out_uleb128 (1 + 1 + enc_size); out_one (DW_OP_GNU_encoded_addr); out_one (encoding); @@ -1409,14 +1805,14 @@ output_cfi_insn (struct cfi_insn_data *insn) insn->u.ea.exp.X_op = O_subtract; insn->u.ea.exp.X_op_symbol = symbol_temp_new_now (); #elif defined (tc_cfi_emit_pcrel_expr) - tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, encoding_size); + tc_cfi_emit_pcrel_expr (&insn->u.ea.exp, enc_size); break; #else abort (); #endif } } - emit_expr (&insn->u.ea.exp, encoding_size); + emit_expr (&insn->u.ea.exp, enc_size); } break; @@ -1429,26 +1825,6 @@ output_cfi_insn (struct cfi_insn_data *insn) } } -static offsetT -encoding_size (unsigned char encoding) -{ - if (encoding == DW_EH_PE_omit) - return 0; - switch (encoding & 0x7) - { - case 0: - return bfd_get_arch_size (stdoutput) == 64 ? 8 : 4; - case DW_EH_PE_udata2: - return 2; - case DW_EH_PE_udata4: - return 4; - case DW_EH_PE_udata8: - return 8; - default: - abort (); - } -} - static void output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align) { @@ -1485,7 +1861,7 @@ output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align) if (fmt != dwarf2_format_32bit) out_four (-1); } - out_one (DW_CIE_VERSION); /* Version. */ + out_one (flag_dwarf_cie_version); /* Version. */ if (eh_frame) { out_one ('z'); /* Augmentation. */ @@ -1494,14 +1870,30 @@ output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align) if (cie->lsda_encoding != DW_EH_PE_omit) out_one ('L'); out_one ('R'); +#ifdef tc_output_cie_extra + tc_output_cie_extra (cie); +#endif } if (cie->signal_frame) out_one ('S'); out_one (0); + if (flag_dwarf_cie_version >= 4) + { + /* For now we are assuming a flat address space with 4 or 8 byte + addresses. */ + int address_size = dwarf2_format_32bit ? 4 : 8; + out_one (address_size); /* Address size. */ + out_one (0); /* Segment size. */ + } out_uleb128 (DWARF2_LINE_MIN_INSN_LENGTH); /* Code alignment. */ out_sleb128 (DWARF2_CIE_DATA_ALIGNMENT); /* Data alignment. */ - if (DW_CIE_VERSION == 1) /* Return column. */ - out_one (cie->return_column); + if (flag_dwarf_cie_version == 1) /* Return column. */ + { + if ((cie->return_column & 0xff) != cie->return_column) + as_bad (_("return column number %d overflows in CIE version 1"), + cie->return_column); + out_one (cie->return_column); + } else out_uleb128 (cie->return_column); if (eh_frame) @@ -1511,26 +1903,7 @@ output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align) augmentation_size += 1 + encoding_size (cie->per_encoding); out_uleb128 (augmentation_size); /* Augmentation size. */ - if (cie->per_encoding != DW_EH_PE_omit) - { - offsetT size = encoding_size (cie->per_encoding); - out_one (cie->per_encoding); - exp = cie->personality; - if ((cie->per_encoding & 0x70) == DW_EH_PE_pcrel) - { -#if CFI_DIFF_EXPR_OK - exp.X_op = O_subtract; - exp.X_op_symbol = symbol_temp_new_now (); - emit_expr (&exp, size); -#elif defined (tc_cfi_emit_pcrel_expr) - tc_cfi_emit_pcrel_expr (&exp, size); -#else - abort (); -#endif - } - else - emit_expr (&exp, size); - } + emit_expr_encoded (&cie->personality, cie->per_encoding, TRUE); if (cie->lsda_encoding != DW_EH_PE_omit) out_one (cie->lsda_encoding); @@ -1553,6 +1926,11 @@ output_cie (struct cie_entry *cie, bfd_boolean eh_frame, int align) #if CFI_DIFF_EXPR_OK || defined tc_cfi_emit_pcrel_expr enc |= DW_EH_PE_pcrel; #endif +#ifdef DWARF2_FDE_RELOC_ENCODING + /* Allow target to override encoding. */ + enc = DWARF2_FDE_RELOC_ENCODING (enc); +#endif + cie->fde_encoding = enc; if (eh_frame) out_one (enc); @@ -1579,8 +1957,8 @@ output_fde (struct fde_entry *fde, struct cie_entry *cie, expressionS exp; offsetT augmentation_size; enum dwarf2_format fmt = DWARF2_FORMAT (now_seg); - int offset_size; - int addr_size; + unsigned int offset_size; + unsigned int addr_size; after_size_address = symbol_temp_make (); end_address = symbol_temp_make (); @@ -1613,30 +1991,45 @@ output_fde (struct fde_entry *fde, struct cie_entry *cie, TC_DWARF2_EMIT_OFFSET (cie->start_address, offset_size); } + exp.X_op = O_symbol; if (eh_frame) { - exp.X_op = O_subtract; - exp.X_add_number = 0; + bfd_reloc_code_real_type code + = tc_cfi_reloc_for_encoding (cie->fde_encoding); + addr_size = DWARF2_FDE_RELOC_SIZE; + if (code != BFD_RELOC_NONE) + { + reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code); + char *p = frag_more (addr_size); + gas_assert (addr_size == (unsigned) howto->bitsize / 8); + md_number_to_chars (p, 0, addr_size); + fix_new (frag_now, p - frag_now->fr_literal, addr_size, + fde->start_address, 0, howto->pc_relative, code); + } + else + { + exp.X_op = O_subtract; + exp.X_add_number = 0; #if CFI_DIFF_EXPR_OK - exp.X_add_symbol = fde->start_address; - exp.X_op_symbol = symbol_temp_new_now (); - emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */ + exp.X_add_symbol = fde->start_address; + exp.X_op_symbol = symbol_temp_new_now (); + emit_expr (&exp, addr_size); /* Code offset. */ #else - exp.X_op = O_symbol; - exp.X_add_symbol = fde->start_address; -#ifdef tc_cfi_emit_pcrel_expr - tc_cfi_emit_pcrel_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */ + exp.X_op = O_symbol; + exp.X_add_symbol = fde->start_address; + +#if defined(tc_cfi_emit_pcrel_expr) + tc_cfi_emit_pcrel_expr (&exp, addr_size); /* Code offset. */ #else - emit_expr (&exp, DWARF2_FDE_RELOC_SIZE); /* Code offset. */ + emit_expr (&exp, addr_size); /* Code offset. */ #endif #endif - addr_size = DWARF2_FDE_RELOC_SIZE; + } } else { - exp.X_op = O_symbol; - exp.X_add_symbol = fde->start_address; exp.X_add_number = 0; + exp.X_add_symbol = fde->start_address; addr_size = DWARF2_ADDR_SIZE (stdoutput); emit_expr (&exp, addr_size); } @@ -1651,24 +2044,7 @@ output_fde (struct fde_entry *fde, struct cie_entry *cie, if (eh_frame) out_uleb128 (augmentation_size); /* Augmentation size. */ - if (fde->lsda_encoding != DW_EH_PE_omit) - { - exp = fde->lsda; - if ((fde->lsda_encoding & 0x70) == DW_EH_PE_pcrel) - { -#if CFI_DIFF_LSDA_OK - exp.X_op = O_subtract; - exp.X_op_symbol = symbol_temp_new_now (); - emit_expr (&exp, augmentation_size); -#elif defined (tc_cfi_emit_pcrel_expr) - tc_cfi_emit_pcrel_expr (&exp, augmentation_size); -#else - abort (); -#endif - } - else - emit_expr (&exp, augmentation_size); - } + emit_expr_encoded (&fde->lsda, cie->lsda_encoding, FALSE); for (; first; first = first->next) if (CUR_SEG (first) == CUR_SEG (fde)) @@ -1689,6 +2065,10 @@ select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame, { if (CUR_SEG (cie) != CUR_SEG (fde)) continue; +#ifdef tc_cie_fde_equivalent_extra + if (!tc_cie_fde_equivalent_extra (cie, fde)) + continue; +#endif if (cie->return_column != fde->return_column || cie->signal_frame != fde->signal_frame || cie->per_encoding != fde->per_encoding @@ -1697,8 +2077,8 @@ select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame, if (cie->per_encoding != DW_EH_PE_omit) { if (cie->personality.X_op != fde->personality.X_op - || cie->personality.X_add_number - != fde->personality.X_add_number) + || (cie->personality.X_add_number + != fde->personality.X_add_number)) continue; switch (cie->personality.X_op) { @@ -1786,7 +2166,7 @@ select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame, fail:; } - cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry)); + cie = XNEW (struct cie_entry); cie->next = cie_root; cie_root = cie; SET_CUR_SEG (cie, CUR_SEG (fde)); @@ -1796,6 +2176,9 @@ select_cie_for_fde (struct fde_entry *fde, bfd_boolean eh_frame, cie->lsda_encoding = fde->lsda_encoding; cie->personality = fde->personality; cie->first = fde->data; +#ifdef tc_cie_entry_init_extra + tc_cie_entry_init_extra (cie, fde) +#endif for (i = cie->first; i ; i = i->next) if (i->insn == DW_CFA_advance_loc @@ -1862,26 +2245,50 @@ cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg) #define cfi_change_reg_numbers(insn, cseg) do { } while (0) #endif -static segT -get_cfi_seg (segT cseg, const char *base, flagword flags, int align) +#if SUPPORT_COMPACT_EH +static void +cfi_emit_eh_header (symbolS *sym, bfd_vma addend) { - if (SUPPORT_FRAME_LINKONCE) - { - struct dwcfi_seg_list *l; + expressionS exp; - l = dwcfi_hash_find_or_make (cseg, base, flags); + exp.X_add_number = addend; + exp.X_add_symbol = sym; + emit_expr_encoded (&exp, DW_EH_PE_sdata4 | DW_EH_PE_pcrel, FALSE); +} - cseg = l->seg; - subseg_set (cseg, l->subseg); +static void +output_eh_header (struct fde_entry *fde) +{ + char *p; + bfd_vma addend; + + if (fde->eh_header_type == EH_COMPACT_INLINE) + addend = 0; + else + addend = 1; + + cfi_emit_eh_header (fde->start_address, addend); + + if (fde->eh_header_type == EH_COMPACT_INLINE) + { + p = frag_more (4); + /* Inline entries always use PR1. */ + *(p++) = 1; + memcpy(p, fde->eh_data, 3); } else { - cseg = subseg_new (base, 0); - bfd_set_section_flags (stdoutput, cseg, flags); + if (fde->eh_header_type == EH_COMPACT_LEGACY) + addend = 1; + else if (fde->eh_header_type == EH_COMPACT_OUTLINE + || fde->eh_header_type == EH_COMPACT_OUTLINE_DONE) + addend = 0; + else + abort (); + cfi_emit_eh_header (fde->eh_loc, addend); } - record_alignment (cseg, align); - return cseg; } +#endif void cfi_finish (void) @@ -1895,13 +2302,15 @@ cfi_finish (void) if (all_fde_data == 0) return; - if ((cfi_sections & CFI_EMIT_eh_frame) != 0) + cfi_sections_set = TRUE; + if ((all_cfi_sections & CFI_EMIT_eh_frame) != 0 + || (all_cfi_sections & CFI_EMIT_eh_frame_compact) != 0) { /* Make sure check_eh_frame doesn't do anything with our output. */ save_flag_traditional_format = flag_traditional_format; flag_traditional_format = 1; - if (!SUPPORT_FRAME_LINKONCE) + if (!EH_FRAME_LINKONCE) { /* Open .eh_frame section. */ cfi_seg = get_cfi_seg (NULL, ".eh_frame", @@ -1929,7 +2338,22 @@ cfi_finish (void) for (fde = all_fde_data; fde ; fde = fde->next) { - if (SUPPORT_FRAME_LINKONCE) + if ((fde->sections & CFI_EMIT_eh_frame) == 0 + && (fde->sections & CFI_EMIT_eh_frame_compact) == 0) + continue; + +#if SUPPORT_COMPACT_EH + /* Emit a LEGACY format header if we have processed all + of the .cfi directives without encountering either inline or + out-of-line compact unwinding opcodes. */ + if (fde->eh_header_type == EH_COMPACT_HAS_LSDA + || fde->eh_header_type == EH_COMPACT_UNKNOWN) + fde->eh_header_type = EH_COMPACT_LEGACY; + + if (fde->eh_header_type != EH_COMPACT_LEGACY) + continue; +#endif + if (EH_FRAME_LINKONCE) { if (HANDLED (fde)) continue; @@ -1958,25 +2382,115 @@ cfi_finish (void) if (fde->end_address == NULL) { - as_bad (_("open CFI at the end of file; missing .cfi_endproc directive")); + as_bad (_("open CFI at the end of file; " + "missing .cfi_endproc directive")); fde->end_address = fde->start_address; } cie = select_cie_for_fde (fde, TRUE, &first, 2); + fde->eh_loc = symbol_temp_new_now (); output_fde (fde, cie, TRUE, first, fde->next == NULL ? EH_FRAME_ALIGNMENT : 2); } } - while (SUPPORT_FRAME_LINKONCE && seek_next_seg == 2); + while (EH_FRAME_LINKONCE && seek_next_seg == 2); - if (SUPPORT_FRAME_LINKONCE) + if (EH_FRAME_LINKONCE) for (fde = all_fde_data; fde ; fde = fde->next) SET_HANDLED (fde, 0); +#if SUPPORT_COMPACT_EH + if (compact_eh) + { + /* Create remaining out of line table entries. */ + do + { + ccseg = NULL; + seek_next_seg = 0; + + for (fde = all_fde_data; fde ; fde = fde->next) + { + if ((fde->sections & CFI_EMIT_eh_frame) == 0 + && (fde->sections & CFI_EMIT_eh_frame_compact) == 0) + continue; + + if (fde->eh_header_type != EH_COMPACT_OUTLINE) + continue; + if (HANDLED (fde)) + continue; + if (seek_next_seg && CUR_SEG (fde) != ccseg) + { + seek_next_seg = 2; + continue; + } + if (!seek_next_seg) + { + ccseg = CUR_SEG (fde); + /* Open .gnu_extab section. */ + get_cfi_seg (ccseg, ".gnu_extab", + (SEC_ALLOC | SEC_LOAD | SEC_DATA + | DWARF2_EH_FRAME_READ_ONLY), + 1); + seek_next_seg = 1; + } + SET_HANDLED (fde, 1); + + frag_align (1, 0, 0); + record_alignment (now_seg, 1); + output_compact_unwind_data (fde, 1); + } + } + while (EH_FRAME_LINKONCE && seek_next_seg == 2); + + for (fde = all_fde_data; fde ; fde = fde->next) + SET_HANDLED (fde, 0); + + /* Create index table fragments. */ + do + { + ccseg = NULL; + seek_next_seg = 0; + + for (fde = all_fde_data; fde ; fde = fde->next) + { + if ((fde->sections & CFI_EMIT_eh_frame) == 0 + && (fde->sections & CFI_EMIT_eh_frame_compact) == 0) + continue; + + if (HANDLED (fde)) + continue; + if (seek_next_seg && CUR_SEG (fde) != ccseg) + { + seek_next_seg = 2; + continue; + } + if (!seek_next_seg) + { + ccseg = CUR_SEG (fde); + /* Open .eh_frame_entry section. */ + cfi_seg = get_cfi_seg (ccseg, ".eh_frame_entry", + (SEC_ALLOC | SEC_LOAD | SEC_DATA + | DWARF2_EH_FRAME_READ_ONLY), + 2); + seek_next_seg = 1; + } + SET_HANDLED (fde, 1); + + output_eh_header (fde); + } + } + while (seek_next_seg == 2); + + for (fde = all_fde_data; fde ; fde = fde->next) + SET_HANDLED (fde, 0); + } +#endif /* SUPPORT_COMPACT_EH */ + flag_traditional_format = save_flag_traditional_format; } - if ((cfi_sections & CFI_EMIT_debug_frame) != 0) + cfi_sections_set = TRUE; + if ((all_cfi_sections & CFI_EMIT_debug_frame) != 0) { int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1; @@ -1999,6 +2513,9 @@ cfi_finish (void) for (fde = all_fde_data; fde ; fde = fde->next) { + if ((fde->sections & CFI_EMIT_debug_frame) == 0) + continue; + if (SUPPORT_FRAME_LINKONCE) { if (HANDLED (fde)) @@ -2021,7 +2538,8 @@ cfi_finish (void) } if (fde->end_address == NULL) { - as_bad (_("open CFI at the end of file; missing .cfi_endproc directive")); + as_bad (_("open CFI at the end of file; " + "missing .cfi_endproc directive")); fde->end_address = fde->start_address; } @@ -2056,6 +2574,7 @@ const pseudo_typeS cfi_pseudo_table[] = { "cfi_sections", dot_cfi_dummy, 0 }, { "cfi_startproc", dot_cfi_dummy, 0 }, { "cfi_endproc", dot_cfi_dummy, 0 }, + { "cfi_fde_data", dot_cfi_dummy, 0 }, { "cfi_def_cfa", dot_cfi_dummy, 0 }, { "cfi_def_cfa_register", dot_cfi_dummy, 0 }, { "cfi_def_cfa_offset", dot_cfi_dummy, 0 }, @@ -2073,9 +2592,12 @@ const pseudo_typeS cfi_pseudo_table[] = { "cfi_escape", dot_cfi_dummy, 0 }, { "cfi_signal_frame", dot_cfi_dummy, 0 }, { "cfi_personality", dot_cfi_dummy, 0 }, + { "cfi_personality_id", dot_cfi_dummy, 0 }, { "cfi_lsda", dot_cfi_dummy, 0 }, { "cfi_val_encoded_addr", dot_cfi_dummy, 0 }, { "cfi_label", dot_cfi_dummy, 0 }, + { "cfi_inline_lsda", dot_cfi_dummy, 0 }, + { "cfi_val_offset", dot_cfi_dummy, 0 }, { NULL, NULL, 0 } };