Changeset 1973 for binutils/trunk/gas/dw2gencfi.c

Timestamp:

Feb 6, 2017, 1:00:00 PM (8 years ago)

Author:

Silvan Scherrer

Message:

binutils: update trunk to version 2.27

Location:

binutils/trunk

Files:

• . (modified) (1 prop)
• gas/dw2gencfi.c (modified) (52 diffs)

binutils/trunk/gas/dw2gencfi.c ¶

@@ -1 +1 @@
 /* dw2gencfi.c - Support for generating Dwarf2 CFI information.
-   Copyright (C) 2003-2014 Free Software Foundation, Inc.
+   Copyright (C) 2003-2016 Free Software Foundation, Inc.
    Contributed by Michal Ludvig <mludvig@suse.cz>
 
@@ -76 +76 @@
 #endif
 
+#define EH_FRAME_LINKONCE (SUPPORT_FRAME_LINKONCE || compact_eh)
+
 #ifndef DWARF2_FORMAT
 #define DWARF2_FORMAT(SEC) dwarf2_format_32bit
@@ -84 +86 @@
 #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
@@ -96 +98 @@
 #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
@@ -104 +110 @@
 };
 
-#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 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 ();
+    }
+}
+
+/* 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)
+{
+  offsetT 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);
+      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_...
@@ -129 +242 @@
 
       if (!dollar && !dot)
-        name = "";
+        {
+          if (!strcmp (base_name, ".eh_frame_entry")
+              && strcmp (name, ".text") != 0)
+            return concat (base_name, ".", name, NULL);
+
+          name = "";
+        }
       else if (!dollar)
         name = dot;
@@ -161 +280 @@
 is_now_linkonce_segment (void)
 {
+  if (compact_eh)
+    return now_seg;
+
   if ((bfd_get_section_flags (stdoutput, now_seg)
        & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
@@ -273 +395 @@
 {
   struct cie_entry *next;
-#if SUPPORT_FRAME_LINKONCE
+#if MULTIPLE_FRAME_SECTIONS
   segT cur_seg;
 #endif
@@ -279 +401 @@
   unsigned int return_column;
   unsigned int signal_frame;
+  unsigned char fde_encoding;
   unsigned char per_encoding;
   unsigned char lsda_encoding;
@@ -315 +438 @@
 alloc_fde_entry (void)
 {
-  struct fde_entry *fde = (struct fde_entry *)
-      xcalloc (1, sizeof (struct fde_entry));
-
-  frchain_now->frch_cfi_data = (struct frch_cfi_data *)
-      xcalloc (1, sizeof (struct frch_cfi_data));
+  struct fde_entry *fde = XCNEW (struct fde_entry);
+
+  frchain_now->frch_cfi_data = XCNEW (struct frch_cfi_data);
   frchain_now->frch_cfi_data->cur_fde_data = fde;
   *last_fde_data = fde;
@@ -329 +450 @@
   fde->per_encoding = DW_EH_PE_omit;
   fde->lsda_encoding = DW_EH_PE_omit;
+  fde->eh_header_type = EH_COMPACT_UNKNOWN;
 
   return fde;
@@ -339 +461 @@
    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;
 
@@ -380 +506 @@
 }
 
+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.  */
 
@@ -440 +573 @@
 
   frchain_now->frch_cfi_data->last_address = label;
+}
+
+/* Add a CFI insn to label the current position in the CFI segment.  */
+
+void
+cfi_add_label (const char *name)
+{
+  unsigned int len = strlen (name) + 1;
+  struct cfi_insn_data *insn = alloc_cfi_insn_data ();
+
+  insn->insn = CFI_label;
+  obstack_grow (&notes, name, len);
+  insn->u.sym_name = (char *) obstack_finish (&notes);
 }
 
@@ -517 +663 @@
   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;
@@ -550 +696 @@
 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[] =
@@ -559 +709 @@
     { "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 },
@@ -576 +727 @@
     { "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 },
     { NULL, NULL, 0 }
   };
@@ -603 +757 @@
       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
@@ -796 +949 @@
   do
     {
-      e = (struct cfi_escape_data *) xmalloc (sizeof (*e));
+      e = XNEW (struct cfi_escape_data);
       do_parse_cons_expression (&e->exp, 1);
       *tail = e;
@@ -835 +988 @@
 
   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)
+           || (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"));
@@ -905 +1059 @@
 
   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
-#endif
-          )
+            && (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)
+           || (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"));
@@ -1019 +1174 @@
 }
 
-/* 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_label (int ignored ATTRIBUTE_UNUSED)
+{
+  char *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 ())
+    cfi_add_advance_loc (symbol_temp_new_now ());
+
+  cfi_add_label (name);
+  free (name);
+
+  demand_empty_rest_of_line ();
+}
 
 static void
@@ -1031 +1200 @@
 
   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
@@ -1044 +1214 @@
         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)
@@ -1051 +1228 @@
           {
             *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;
@@ -1067 +1244 @@
               }
           }
-        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 && cfi_sections != sections)
+    as_bad (_("inconsistent uses of .cfi_sections"));
   cfi_sections = sections;
 }
@@ -1090 +1269 @@
 
   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)
@@ -1118 +1300 @@
 dot_cfi_endproc (int ignored ATTRIBUTE_UNUSED)
 {
-  struct fde_entry *fde;
-
   if (frchain_now->frch_cfi_data == NULL)
     {
@@ -1127 +1307 @@
     }
 
+  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 (last_fde);
+}
+
+static segT
+get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
+{
+  /* 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 (stdoutput, cseg, flags);
+    }
+  record_alignment (cseg, align);
+  return cseg;
+}
+
+#if SUPPORT_COMPACT_EH
+static void
+dot_cfi_personality_id (int ignored ATTRIBUTE_UNUSED)
+{
+  struct fde_entry *fde;
+
+  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;
-
-  cfi_end_fde (symbol_temp_new_now ());
-
+  fde->personality_id = cfi_parse_const ();
   demand_empty_rest_of_line ();
 
-  if ((cfi_sections & CFI_EMIT_target) != 0)
-    tc_cfi_endproc (fde);
-}
-
-
-
-/* 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);
-}
+  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)
+{
+  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 ();
+}
+
+/* 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 void
+output_compact_unwind_data (struct fde_entry *fde, int align)
+{
+  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;
+}
+
+/* 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
+dot_cfi_inline_lsda (int ignored ATTRIBUTE_UNUSED)
+{
+  as_bad (_(".cfi_inline_lsda is not supported for this target"));
+  ignore_rest_of_line ();
+}
+
+static void
+dot_cfi_fde_data (int ignored ATTRIBUTE_UNUSED)
+{
+  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
@@ -1335 +1712 @@
       {
         unsigned encoding = insn->u.ea.encoding;
-        offsetT encoding_size;
+        offsetT enc_size;
 
         if (encoding == DW_EH_PE_omit)
@@ -1345 +1722 @@
           {
           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:
@@ -1364 +1741 @@
         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);
@@ -1379 +1756 @@
                 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
@@ -1386 +1763 @@
               }
           }
-        emit_expr (&insn->u.ea.exp, encoding_size);
+        emit_expr (&insn->u.ea.exp, enc_size);
       }
       break;
 
-    default:
-      abort ();
-    }
-}
-
-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;
+    case CFI_label:
+      colon (insn->u.sym_name);
+      break;
+
     default:
       abort ();
@@ -1477 +1838 @@
       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)
@@ -1519 +1861 @@
   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 +1926 @@
     }
 
+  exp.X_op = O_symbol;
   if (eh_frame)
     {
-      exp.X_op = O_subtract;
+      bfd_reloc_code_real_type code
+        = tc_cfi_reloc_for_encoding (cie->fde_encoding);
+      if (code != BFD_RELOC_NONE)
+        {
+          reloc_howto_type *howto = bfd_reloc_type_lookup (stdoutput, code);
+          char *p = frag_more (4);
+          md_number_to_chars (p, 0, 4);
+          fix_new (frag_now, p - frag_now->fr_literal, 4, 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.  */
+#else
+          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, DWARF2_FDE_RELOC_SIZE);  /* Code offset.  */
+#else
+          emit_expr (&exp, DWARF2_FDE_RELOC_SIZE);      /* Code offset.  */
+#endif
+#endif
+        }
+      addr_size = DWARF2_FDE_RELOC_SIZE;
+    }
+  else
+    {
       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.  */
-#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.  */
-#else
-      emit_expr (&exp, DWARF2_FDE_RELOC_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;
       addr_size = DWARF2_ADDR_SIZE (stdoutput);
       emit_expr (&exp, addr_size);
@@ -1617 +1978 @@
     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)
@@ -1725 +2069 @@
             case CFI_escape:
             case CFI_val_encoded_addr:
+            case CFI_label:
               /* Don't bother matching these for now.  */
               goto fail;
@@ -1741 +2086 @@
               || j->insn == DW_CFA_remember_state
               || j->insn == CFI_escape
-              || j->insn == CFI_val_encoded_addr))
+              || j->insn == CFI_val_encoded_addr
+              || j->insn == CFI_label))
         {
           *pfirst = j;
@@ -1750 +2096 @@
     }
 
-  cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
+  cie = XNEW (struct cie_entry);
   cie->next = cie_root;
   cie_root = cie;
@@ -1765 +2111 @@
         || i->insn == DW_CFA_remember_state
         || i->insn == CFI_escape
-        || i->insn == CFI_val_encoded_addr)
+        || i->insn == CFI_val_encoded_addr
+        || i->insn == CFI_label)
       break;
 
@@ -1792 +2139 @@
         case DW_CFA_GNU_window_save:
         case CFI_escape:
+        case CFI_label:
           break;
 
@@ -1824 +2172 @@
 #endif
 
-static segT
-get_cfi_seg (segT cseg, const char *base, flagword flags, int align)
-{
-  if (SUPPORT_FRAME_LINKONCE)
-    {
-      struct dwcfi_seg_list *l;
-
-      l = dwcfi_hash_find_or_make (cseg, base, flags);
-
-      cseg = l->seg;
-      subseg_set (cseg, l->subseg);
-    }
+#if SUPPORT_COMPACT_EH
+static void
+cfi_emit_eh_header (symbolS *sym, bfd_vma addend)
+{
+  expressionS exp;
+
+  exp.X_add_number = addend;
+  exp.X_add_symbol = sym;
+  emit_expr_encoded (&exp, DW_EH_PE_sdata4 | DW_EH_PE_pcrel, FALSE);
+}
+
+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
-    {
-      cseg = subseg_new (base, 0);
-      bfd_set_section_flags (stdoutput, cseg, flags);
-    }
-  record_alignment (cseg, align);
-  return cseg;
-}
+    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
+    {
+      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);
+    }
+}
+#endif
 
 void
@@ -1857 +2229 @@
     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.  */
@@ -1863 +2237 @@
       flag_traditional_format = 1;
 
-      if (!SUPPORT_FRAME_LINKONCE)
+      if (!EH_FRAME_LINKONCE)
         {
           /* Open .eh_frame section.  */
@@ -1891 +2265 @@
           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))
@@ -1925 +2314 @@
 
               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);
-
-      if (SUPPORT_FRAME_LINKONCE)
+      while (EH_FRAME_LINKONCE && seek_next_seg == 2);
+
+      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;
@@ -1961 +2439 @@
           for (fde = all_fde_data; fde ; fde = fde->next)
             {
+              if ((fde->sections & CFI_EMIT_debug_frame) == 0)
+                continue;
+
               if (SUPPORT_FRAME_LINKONCE)
                 {
@@ -2018 +2499 @@
     { "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 },
@@ -2035 +2517 @@
     { "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 },
     { NULL, NULL, 0 }
   };