* elf-eh-frame.c (struct cie): New type.

	(cie_compare): Removed.
	(cie_eq, cie_hash, cie_compute_hash): New functions.
	(_bfd_elf_discard_section_eh_frame): Rewrite not to rely on FDEs
	pointing only to last CIE and allow merging of any duplicate CIEs,
	not just duplicate consecutive CIEs.
	(_bfd_elf_discard_section_eh_frame_hdr): Delete cies hash table.
	* elf-bfd.h (struct cie_header, struct cie): Removed.
	(struct eh_frame_sec_info): Remove alloced field.
	(struct eh_frame_hdr_info): Remove last_cie, last_cie_sec
	and last_cie_inf fields.  Add cies field.

	* ld-elf/eh5.d: New test.
	* ld-elf/eh5.s: New file.
	* ld-elf/eh5a.s: New file.
	* ld-elf/eh5b.s: New file.

1 files changed, 245 insertions, 153 deletions

diff --git a/bfd/elf-eh-frame.c b/bfd/elf-eh-frame.c
index 859f534b15..2aa61e14e2 100644
--- a/bfd/elf-eh-frame.c
+++ b/bfd/elf-eh-frame.c
@@ -26,6 +26,30 @@
 
 #define EH_FRAME_HDR_SIZE 8
 
+struct cie
+{
+  unsigned int length;
+  unsigned int hash;
+  unsigned char version;
+  char augmentation[20];
+  bfd_vma code_align;
+  bfd_signed_vma data_align;
+  bfd_vma ra_column;
+  bfd_vma augmentation_size;
+  struct elf_link_hash_entry *personality;
+  asection *output_sec;
+  struct eh_cie_fde *cie_inf;
+  unsigned char per_encoding;
+  unsigned char lsda_encoding;
+  unsigned char fde_encoding;
+  unsigned char initial_insn_length;
+  unsigned char make_relative;
+  unsigned char make_lsda_relative;
+  unsigned char initial_instructions[50];
+};
+
+
+
 /* If *ITER hasn't reached END yet, read the next byte into *RESULT and
    move onto the next byte.  Return true on success.  */
 
@@ -180,12 +204,16 @@ write_value (bfd *abfd, bfd_byte *buf, bfd_vma value, int width)
     }
 }
 
-/* Return zero if C1 and C2 CIEs can be merged.  */
+/* Return one if C1 and C2 CIEs can be merged.  */
 
-static
-int cie_compare (struct cie *c1, struct cie *c2)
+static int
+cie_eq (const void *e1, const void *e2)
 {
-  if (c1->hdr.length == c2->hdr.length
+  const struct cie *c1 = e1;
+  const struct cie *c2 = e2;
+
+  if (c1->hash == c2->hash
+      && c1->length == c2->length
       && c1->version == c2->version
       && strcmp (c1->augmentation, c2->augmentation) == 0
       && strcmp (c1->augmentation, "eh") != 0
@@ -194,6 +222,7 @@ int cie_compare (struct cie *c1, struct cie *c2)
       && c1->ra_column == c2->ra_column
       && c1->augmentation_size == c2->augmentation_size
       && c1->personality == c2->personality
+      && c1->output_sec == c2->output_sec
       && c1->per_encoding == c2->per_encoding
       && c1->lsda_encoding == c2->lsda_encoding
       && c1->fde_encoding == c2->fde_encoding
@@ -201,9 +230,38 @@ int cie_compare (struct cie *c1, struct cie *c2)
       && memcmp (c1->initial_instructions,
 		 c2->initial_instructions,
 		 c1->initial_insn_length) == 0)
-    return 0;
+    return 1;
 
-  return 1;
+  return 0;
+}
+
+static hashval_t
+cie_hash (const void *e)
+{
+  const struct cie *c = e;
+  return c->hash;
+}
+
+static hashval_t
+cie_compute_hash (struct cie *c)
+{
+  hashval_t h = 0;
+  h = iterative_hash_object (c->length, h);
+  h = iterative_hash_object (c->version, h);
+  h = iterative_hash (c->augmentation, strlen (c->augmentation) + 1, h);
+  h = iterative_hash_object (c->code_align, h);
+  h = iterative_hash_object (c->data_align, h);
+  h = iterative_hash_object (c->ra_column, h);
+  h = iterative_hash_object (c->augmentation_size, h);
+  h = iterative_hash_object (c->personality, h);
+  h = iterative_hash_object (c->output_sec, h);
+  h = iterative_hash_object (c->per_encoding, h);
+  h = iterative_hash_object (c->lsda_encoding, h);
+  h = iterative_hash_object (c->fde_encoding, h);
+  h = iterative_hash_object (c->initial_insn_length, h);
+  h = iterative_hash (c->initial_instructions, c->initial_insn_length, h);
+  c->hash = h;
+  return h;
 }
 
 /* Return the number of extra bytes that we'll be inserting into
@@ -383,15 +441,24 @@ _bfd_elf_discard_section_eh_frame
   while (0)
 
   bfd_byte *ehbuf = NULL, *buf;
-  bfd_byte *last_cie, *last_fde;
-  struct eh_cie_fde *ent, *last_cie_inf, *this_inf;
-  struct cie_header hdr;
-  struct cie cie;
+  bfd_byte *last_fde;
+  struct eh_cie_fde *ent, *this_inf;
+  unsigned int hdr_length, hdr_id;
+  struct extended_cie
+    {
+      struct cie cie;
+      unsigned int offset;
+      unsigned int usage_count;
+      unsigned int entry;
+    } *ecies = NULL, *ecie;
+  unsigned int ecie_count = 0, ecie_alloced = 0;
+  struct cie *cie;
   struct elf_link_hash_table *htab;
   struct eh_frame_hdr_info *hdr_info;
   struct eh_frame_sec_info *sec_info = NULL;
-  unsigned int cie_usage_count, offset;
+  unsigned int offset;
   unsigned int ptr_size;
+  unsigned int entry_alloced;
 
   if (sec->size == 0)
     {
@@ -409,6 +476,9 @@ _bfd_elf_discard_section_eh_frame
   htab = elf_hash_table (info);
   hdr_info = &htab->eh_info;
 
+  if (hdr_info->cies == NULL && !info->relocatable)
+    hdr_info->cies = htab_try_create (1, cie_hash, cie_eq, free);
+
   /* Read the frame unwind information from abfd.  */
 
   REQUIRE (bfd_malloc_and_get_section (abfd, sec, &ehbuf));
@@ -431,15 +501,11 @@ _bfd_elf_discard_section_eh_frame
   REQUIRE (ptr_size != 0);
 
   buf = ehbuf;
-  last_cie = NULL;
-  last_cie_inf = NULL;
-  memset (&cie, 0, sizeof (cie));
-  cie_usage_count = 0;
   sec_info = bfd_zmalloc (sizeof (struct eh_frame_sec_info)
 			  + 99 * sizeof (struct eh_cie_fde));
   REQUIRE (sec_info);
 
-  sec_info->alloced = 100;
+  entry_alloced = 100;
 
 #define ENSURE_NO_RELOCS(buf)				\
   REQUIRE (!(cookie->rel < cookie->relend		\
@@ -466,116 +532,80 @@ _bfd_elf_discard_section_eh_frame
       bfd_size_type length;
       unsigned int set_loc_count;
 
-      if (sec_info->count == sec_info->alloced)
+      if (sec_info->count == entry_alloced)
 	{
-	  struct eh_cie_fde *old_entry = sec_info->entry;
 	  sec_info = bfd_realloc (sec_info,
 				  sizeof (struct eh_frame_sec_info)
-				  + ((sec_info->alloced + 99)
+				  + ((entry_alloced + 99)
 				     * sizeof (struct eh_cie_fde)));
 	  REQUIRE (sec_info);
 
-	  memset (&sec_info->entry[sec_info->alloced], 0,
+	  memset (&sec_info->entry[entry_alloced], 0,
 		  100 * sizeof (struct eh_cie_fde));
-	  sec_info->alloced += 100;
-
-	  /* Now fix any pointers into the array.  */
-	  if (last_cie_inf >= old_entry
-	      && last_cie_inf < old_entry + sec_info->count)
-	    last_cie_inf = sec_info->entry + (last_cie_inf - old_entry);
+	  entry_alloced += 100;
 	}
 
       this_inf = sec_info->entry + sec_info->count;
       last_fde = buf;
-      /* If we are at the end of the section, we still need to decide
-	 on whether to output or discard last encountered CIE (if any).  */
+
       if ((bfd_size_type) (buf - ehbuf) == sec->size)
-	{
-	  hdr.length = 0;
-	  hdr.id = (unsigned int) -1;
-	  end = buf;
-	}
-      else
-	{
-	  /* Read the length of the entry.  */
-	  REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
-	  hdr.length = bfd_get_32 (abfd, buf - 4);
+	break;
 
-	  /* 64-bit .eh_frame is not supported.  */
-	  REQUIRE (hdr.length != 0xffffffff);
+      /* Read the length of the entry.  */
+      REQUIRE (skip_bytes (&buf, ehbuf + sec->size, 4));
+      hdr_length = bfd_get_32 (abfd, buf - 4);
 
-	  /* The CIE/FDE must be fully contained in this input section.  */
-	  REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr.length <= sec->size);
-	  end = buf + hdr.length;
+      /* 64-bit .eh_frame is not supported.  */
+      REQUIRE (hdr_length != 0xffffffff);
 
-	  this_inf->offset = last_fde - ehbuf;
-	  this_inf->size = 4 + hdr.length;
+      /* The CIE/FDE must be fully contained in this input section.  */
+      REQUIRE ((bfd_size_type) (buf - ehbuf) + hdr_length <= sec->size);
+      end = buf + hdr_length;
 
-	  if (hdr.length == 0)
-	    {
-	      /* A zero-length CIE should only be found at the end of
-		 the section.  */
-	      REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
-	      ENSURE_NO_RELOCS (buf);
-	      sec_info->count++;
-	      /* Now just finish last encountered CIE processing and break
-		 the loop.  */
-	      hdr.id = (unsigned int) -1;
-	    }
-	  else
-	    {
-	      REQUIRE (skip_bytes (&buf, end, 4));
-	      hdr.id = bfd_get_32 (abfd, buf - 4);
-	      REQUIRE (hdr.id != (unsigned int) -1);
-	    }
+      this_inf->offset = last_fde - ehbuf;
+      this_inf->size = 4 + hdr_length;
+
+      if (hdr_length == 0)
+	{
+	  /* A zero-length CIE should only be found at the end of
+	     the section.  */
+	  REQUIRE ((bfd_size_type) (buf - ehbuf) == sec->size);
+	  ENSURE_NO_RELOCS (buf);
+	  sec_info->count++;
+	  break;
 	}
 
-      if (hdr.id == 0 || hdr.id == (unsigned int) -1)
+      REQUIRE (skip_bytes (&buf, end, 4));
+      hdr_id = bfd_get_32 (abfd, buf - 4);
+
+      if (hdr_id == 0)
 	{
 	  unsigned int initial_insn_length;
 
 	  /* CIE  */
-	  if (last_cie != NULL)
+	  this_inf->cie = 1;
+
+	  if (ecie_count == ecie_alloced)
 	    {
-	      /* Now check if this CIE is identical to the last CIE,
-		 in which case we can remove it provided we adjust
-		 all FDEs.  Also, it can be removed if we have removed
-		 all FDEs using it.  */
-	      if ((!info->relocatable
-		   && hdr_info->last_cie_sec
-		   && (sec->output_section
-		       == hdr_info->last_cie_sec->output_section)
-		   && cie_compare (&cie, &hdr_info->last_cie) == 0)
-		  || cie_usage_count == 0)
-		last_cie_inf->removed = 1;
-	      else
-		{
-		  hdr_info->last_cie = cie;
-		  hdr_info->last_cie_sec = sec;
-		  last_cie_inf->make_relative = cie.make_relative;
-		  last_cie_inf->make_lsda_relative = cie.make_lsda_relative;
-		  last_cie_inf->per_encoding_relative
-		    = (cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
-		}
+	      ecies = bfd_realloc (ecies,
+				   (ecie_alloced + 20) * sizeof (*ecies));
+	      REQUIRE (ecies);
+	      memset (&ecies[ecie_alloced], 0, 20 * sizeof (*ecies));
+	      ecie_alloced += 20;
 	    }
 
-	  if (hdr.id == (unsigned int) -1)
-	    break;
-
-	  last_cie_inf = this_inf;
-	  this_inf->cie = 1;
-
-	  cie_usage_count = 0;
-	  memset (&cie, 0, sizeof (cie));
-	  cie.hdr = hdr;
+	  cie = &ecies[ecie_count].cie;
+	  ecies[ecie_count].offset = this_inf->offset;
+	  ecies[ecie_count++].entry = sec_info->count;
+	  cie->length = hdr_length;
 	  start = buf;
-	  REQUIRE (read_byte (&buf, end, &cie.version));
+	  REQUIRE (read_byte (&buf, end, &cie->version));
 
 	  /* Cannot handle unknown versions.  */
-	  REQUIRE (cie.version == 1 || cie.version == 3);
-	  REQUIRE (strlen ((char *) buf) < sizeof (cie.augmentation));
+	  REQUIRE (cie->version == 1 || cie->version == 3);
+	  REQUIRE (strlen ((char *) buf) < sizeof (cie->augmentation));
 
-	  strcpy (cie.augmentation, (char *) buf);
+	  strcpy (cie->augmentation, (char *) buf);
 	  buf = (bfd_byte *) strchr ((char *) buf, '\0') + 1;
 	  ENSURE_NO_RELOCS (buf);
 	  if (buf[0] == 'e' && buf[1] == 'h')
@@ -587,26 +617,26 @@ _bfd_elf_discard_section_eh_frame
 	      REQUIRE (skip_bytes (&buf, end, ptr_size));
 	      SKIP_RELOCS (buf);
 	    }
-	  REQUIRE (read_uleb128 (&buf, end, &cie.code_align));
-	  REQUIRE (read_sleb128 (&buf, end, &cie.data_align));
-	  if (cie.version == 1)
+	  REQUIRE (read_uleb128 (&buf, end, &cie->code_align));
+	  REQUIRE (read_sleb128 (&buf, end, &cie->data_align));
+	  if (cie->version == 1)
 	    {
 	      REQUIRE (buf < end);
-	      cie.ra_column = *buf++;
+	      cie->ra_column = *buf++;
 	    }
 	  else
-	    REQUIRE (read_uleb128 (&buf, end, &cie.ra_column));
+	    REQUIRE (read_uleb128 (&buf, end, &cie->ra_column));
 	  ENSURE_NO_RELOCS (buf);
-	  cie.lsda_encoding = DW_EH_PE_omit;
-	  cie.fde_encoding = DW_EH_PE_omit;
-	  cie.per_encoding = DW_EH_PE_omit;
-	  aug = cie.augmentation;
+	  cie->lsda_encoding = DW_EH_PE_omit;
+	  cie->fde_encoding = DW_EH_PE_omit;
+	  cie->per_encoding = DW_EH_PE_omit;
+	  aug = cie->augmentation;
 	  if (aug[0] != 'e' || aug[1] != 'h')
 	    {
 	      if (*aug == 'z')
 		{
 		  aug++;
-		  REQUIRE (read_uleb128 (&buf, end, &cie.augmentation_size));
+		  REQUIRE (read_uleb128 (&buf, end, &cie->augmentation_size));
 	  	  ENSURE_NO_RELOCS (buf);
 		}
 
@@ -614,14 +644,14 @@ _bfd_elf_discard_section_eh_frame
 		switch (*aug++)
 		  {
 		  case 'L':
-		    REQUIRE (read_byte (&buf, end, &cie.lsda_encoding));
+		    REQUIRE (read_byte (&buf, end, &cie->lsda_encoding));
 		    ENSURE_NO_RELOCS (buf);
-		    REQUIRE (get_DW_EH_PE_width (cie.lsda_encoding, ptr_size));
+		    REQUIRE (get_DW_EH_PE_width (cie->lsda_encoding, ptr_size));
 		    break;
 		  case 'R':
-		    REQUIRE (read_byte (&buf, end, &cie.fde_encoding));
+		    REQUIRE (read_byte (&buf, end, &cie->fde_encoding));
 		    ENSURE_NO_RELOCS (buf);
-		    REQUIRE (get_DW_EH_PE_width (cie.fde_encoding, ptr_size));
+		    REQUIRE (get_DW_EH_PE_width (cie->fde_encoding, ptr_size));
 		    break;
 		  case 'S':
 		    break;
@@ -629,11 +659,11 @@ _bfd_elf_discard_section_eh_frame
 		    {
 		      int per_width;
 
-		      REQUIRE (read_byte (&buf, end, &cie.per_encoding));
-		      per_width = get_DW_EH_PE_width (cie.per_encoding,
+		      REQUIRE (read_byte (&buf, end, &cie->per_encoding));
+		      per_width = get_DW_EH_PE_width (cie->per_encoding,
 						      ptr_size);
 		      REQUIRE (per_width);
-		      if ((cie.per_encoding & 0xf0) == DW_EH_PE_aligned)
+		      if ((cie->per_encoding & 0xf0) == DW_EH_PE_aligned)
 			{
 			  length = -(buf - ehbuf) & (per_width - 1);
 			  REQUIRE (skip_bytes (&buf, end, length));
@@ -663,7 +693,7 @@ _bfd_elf_discard_section_eh_frame
 				h = (struct elf_link_hash_entry *)
 				    h->root.u.i.link;
 
-			      cie.personality = h;
+			      cie->personality = h;
 			    }
 			  /* Cope with MIPS-style composite relocations.  */
 			  do
@@ -671,6 +701,7 @@ _bfd_elf_discard_section_eh_frame
 			  while (GET_RELOC (buf) != NULL);
 			}
 		      REQUIRE (skip_bytes (&buf, end, per_width));
+		      REQUIRE (cie->personality);
 		    }
 		    break;
 		  default:
@@ -686,18 +717,18 @@ _bfd_elf_discard_section_eh_frame
 		  ->elf_backend_can_make_relative_eh_frame
 		  (abfd, info, sec)))
 	    {
-	      if ((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr)
-		cie.make_relative = 1;
+	      if ((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr)
+		cie->make_relative = 1;
 	      /* If the CIE doesn't already have an 'R' entry, it's fairly
 		 easy to add one, provided that there's no aligned data
 		 after the augmentation string.  */
-	      else if (cie.fde_encoding == DW_EH_PE_omit
-		       && (cie.per_encoding & 0xf0) != DW_EH_PE_aligned)
+	      else if (cie->fde_encoding == DW_EH_PE_omit
+		       && (cie->per_encoding & 0xf0) != DW_EH_PE_aligned)
 		{
-		  if (*cie.augmentation == 0)
+		  if (*cie->augmentation == 0)
 		    this_inf->add_augmentation_size = 1;
 		  this_inf->add_fde_encoding = 1;
-		  cie.make_relative = 1;
+		  cie->make_relative = 1;
 		}
 	    }
 
@@ -705,30 +736,36 @@ _bfd_elf_discard_section_eh_frame
 	      && (get_elf_backend_data (abfd)
 		  ->elf_backend_can_make_lsda_relative_eh_frame
 		  (abfd, info, sec))
-	      && (cie.lsda_encoding & 0xf0) == DW_EH_PE_absptr)
-	    cie.make_lsda_relative = 1;
+	      && (cie->lsda_encoding & 0xf0) == DW_EH_PE_absptr)
+	    cie->make_lsda_relative = 1;
 
 	  /* If FDE encoding was not specified, it defaults to
 	     DW_EH_absptr.  */
-	  if (cie.fde_encoding == DW_EH_PE_omit)
-	    cie.fde_encoding = DW_EH_PE_absptr;
+	  if (cie->fde_encoding == DW_EH_PE_omit)
+	    cie->fde_encoding = DW_EH_PE_absptr;
 
 	  initial_insn_length = end - buf;
-	  if (initial_insn_length <= 50)
+	  if (initial_insn_length <= sizeof (cie->initial_instructions))
 	    {
-	      cie.initial_insn_length = initial_insn_length;
-	      memcpy (cie.initial_instructions, buf, initial_insn_length);
+	      cie->initial_insn_length = initial_insn_length;
+	      memcpy (cie->initial_instructions, buf, initial_insn_length);
 	    }
 	  insns = buf;
 	  buf += initial_insn_length;
 	  ENSURE_NO_RELOCS (buf);
-	  last_cie = last_fde;
 	}
       else
 	{
-	  /* Ensure this FDE uses the last CIE encountered.  */
-	  REQUIRE (last_cie);
-	  REQUIRE (hdr.id == (unsigned int) (buf - 4 - last_cie));
+	  /* Find the corresponding CIE.  */
+	  unsigned int cie_offset = this_inf->offset + 4 - hdr_id;
+	  for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
+	    if (cie_offset == ecie->offset)
+	      break;
+
+	  /* Ensure this FDE references one of the CIEs in this input
+	     section.  */
+	  REQUIRE (ecie != ecies + ecie_count);
+	  cie = &ecie->cie;
 
 	  ENSURE_NO_RELOCS (buf);
 	  REQUIRE (GET_RELOC (buf));
@@ -740,9 +777,9 @@ _bfd_elf_discard_section_eh_frame
 	  else
 	    {
 	      if (info->shared
-		  && (((cie.fde_encoding & 0xf0) == DW_EH_PE_absptr
-		       && cie.make_relative == 0)
-		      || (cie.fde_encoding & 0xf0) == DW_EH_PE_aligned))
+		  && (((cie->fde_encoding & 0xf0) == DW_EH_PE_absptr
+		       && cie->make_relative == 0)
+		      || (cie->fde_encoding & 0xf0) == DW_EH_PE_aligned))
 		{
 		  /* If a shared library uses absolute pointers
 		     which we cannot turn into PC relative,
@@ -750,16 +787,18 @@ _bfd_elf_discard_section_eh_frame
 		     since it is affected by runtime relocations.  */
 		  hdr_info->table = FALSE;
 		}
-	      cie_usage_count++;
+	      ecie->usage_count++;
 	      hdr_info->fde_count++;
+	      this_inf->cie_inf = (void *) (ecie - ecies);
 	    }
+
 	  /* Skip the initial location and address range.  */
 	  start = buf;
-	  length = get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
+	  length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
 	  REQUIRE (skip_bytes (&buf, end, 2 * length));
 
 	  /* Skip the augmentation size, if present.  */
-	  if (cie.augmentation[0] == 'z')
+	  if (cie->augmentation[0] == 'z')
 	    REQUIRE (read_uleb128 (&buf, end, &length));
 	  else
 	    length = 0;
@@ -767,12 +806,12 @@ _bfd_elf_discard_section_eh_frame
 	  /* Of the supported augmentation characters above, only 'L'
 	     adds augmentation data to the FDE.  This code would need to
 	     be adjusted if any future augmentations do the same thing.  */
-	  if (cie.lsda_encoding != DW_EH_PE_omit)
+	  if (cie->lsda_encoding != DW_EH_PE_omit)
 	    {
 	      this_inf->lsda_offset = buf - start;
 	      /* If there's no 'z' augmentation, we don't know where the
 		 CFA insns begin.  Assume no padding.  */
-	      if (cie.augmentation[0] != 'z')
+	      if (cie->augmentation[0] != 'z')
 		length = end - buf;
 	    }
 
@@ -780,14 +819,14 @@ _bfd_elf_discard_section_eh_frame
 	  REQUIRE (skip_bytes (&buf, end, length));
 	  insns = buf;
 
-	  buf = last_fde + 4 + hdr.length;
+	  buf = last_fde + 4 + hdr_length;
 	  SKIP_RELOCS (buf);
 	}
 
       /* Try to interpret the CFA instructions and find the first
 	 padding nop.  Shrink this_inf's size so that it doesn't
 	 include the padding.  */
-      length = get_DW_EH_PE_width (cie.fde_encoding, ptr_size);
+      length = get_DW_EH_PE_width (cie->fde_encoding, ptr_size);
       set_loc_count = 0;
       insns_end = skip_non_nops (insns, end, length, &set_loc_count);
       /* If we don't understand the CFA instructions, we can't know
@@ -798,9 +837,14 @@ _bfd_elf_discard_section_eh_frame
 	  || (set_loc_count && this_inf->cie))
 	goto free_no_table;
       this_inf->size -= end - insns_end;
+      if (insns_end != end && this_inf->cie)
+	{
+	  cie->initial_insn_length -= end - insns_end;
+	  cie->length -= end - insns_end;
+	}
       if (set_loc_count
-	  && ((cie.fde_encoding & 0xf0) == DW_EH_PE_pcrel
-	      || cie.make_relative))
+	  && ((cie->fde_encoding & 0xf0) == DW_EH_PE_pcrel
+	      || cie->make_relative))
 	{
 	  unsigned int cnt;
 	  bfd_byte *p;
@@ -819,28 +863,66 @@ _bfd_elf_discard_section_eh_frame
 	    }
 	}
 
-      this_inf->fde_encoding = cie.fde_encoding;
-      this_inf->lsda_encoding = cie.lsda_encoding;
+      this_inf->fde_encoding = cie->fde_encoding;
+      this_inf->lsda_encoding = cie->lsda_encoding;
       sec_info->count++;
     }
 
   elf_section_data (sec)->sec_info = sec_info;
   sec->sec_info_type = ELF_INFO_TYPE_EH_FRAME;
 
+  /* Look at all CIEs in this section and determine which can be
+     removed as unused, which can be merged with previous duplicate
+     CIEs and which need to be kept.  */
+  for (ecie = ecies; ecie < ecies + ecie_count; ++ecie)
+    {
+      if (ecie->usage_count == 0)
+	{
+	  sec_info->entry[ecie->entry].removed = 1;
+	  continue;
+	}
+      ecie->cie.output_sec = sec->output_section;
+      ecie->cie.cie_inf = sec_info->entry + ecie->entry;
+      cie_compute_hash (&ecie->cie);
+      if (hdr_info->cies != NULL)
+	{
+	  void **loc = htab_find_slot_with_hash (hdr_info->cies, &ecie->cie,
+						 ecie->cie.hash, INSERT);
+	  if (loc != NULL)
+	    {
+	      if (*loc != HTAB_EMPTY_ENTRY)
+		{
+		  sec_info->entry[ecie->entry].removed = 1;
+		  ecie->cie.cie_inf = ((struct cie *) *loc)->cie_inf;
+		  continue;
+		}
+
+	      *loc = malloc (sizeof (struct cie));
+	      if (*loc == NULL)
+		*loc = HTAB_DELETED_ENTRY;
+	      else
+		memcpy (*loc, &ecie->cie, sizeof (struct cie));
+	    }
+	}
+      ecie->cie.cie_inf->make_relative = ecie->cie.make_relative;
+      ecie->cie.cie_inf->make_lsda_relative = ecie->cie.make_lsda_relative;
+      ecie->cie.cie_inf->per_encoding_relative
+	= (ecie->cie.per_encoding & 0x70) == DW_EH_PE_pcrel;
+    }
+
   /* Ok, now we can assign new offsets.  */
   offset = 0;
-  last_cie_inf = hdr_info->last_cie_inf;
   for (ent = sec_info->entry; ent < sec_info->entry + sec_info->count; ++ent)
     if (!ent->removed)
       {
-	if (ent->cie)
-	  last_cie_inf = ent;
-	else
-	  ent->cie_inf = last_cie_inf;
+	if (!ent->cie)
+	  {
+	    ecie = ecies + (unsigned long) ent->cie_inf;
+	    ent->cie_inf = ecie->cie.cie_inf;
+	  }
 	ent->new_offset = offset;
 	offset += size_of_output_cie_fde (ent, ptr_size);
       }
-  hdr_info->last_cie_inf = last_cie_inf;
 
   /* Resize the sec as needed.  */
   sec->rawsize = sec->size;
@@ -849,6 +931,8 @@ _bfd_elf_discard_section_eh_frame
     sec->flags |= SEC_EXCLUDE;
 
   free (ehbuf);
+  if (ecies)
+    free (ecies);
   return offset != sec->rawsize;
 
 free_no_table:
@@ -856,8 +940,9 @@ free_no_table:
     free (ehbuf);
   if (sec_info)
     free (sec_info);
+  if (ecies)
+    free (ecies);
   hdr_info->table = FALSE;
-  hdr_info->last_cie.hdr.length = 0;
   return FALSE;
 
 #undef REQUIRE
@@ -876,6 +961,13 @@ _bfd_elf_discard_section_eh_frame_hdr (bfd *abfd, struct bfd_link_info *info)
 
   htab = elf_hash_table (info);
   hdr_info = &htab->eh_info;
+
+  if (hdr_info->cies != NULL)
+    {
+      htab_delete (hdr_info->cies);
+      hdr_info->cies = NULL;
+    }
+
   sec = hdr_info->hdr_sec;
   if (sec == NULL)
     return FALSE;