File binutils-2.21-oom.patch of Package mingw64-binutils

Overview Repositories Revisions Requests Users Attributes Meta

File binutils-2.21-oom.patch of Package mingw64-binutils (Revision bf68ac044fd09ec28ea3c81af8ba09ac)

Currently displaying revision bf68ac044fd09ec28ea3c81af8ba09ac , Show latest

--- binutils-2.21/bfd/coffcode.h	2010-11-04 17:03:22.000000000 +0100
+++ binutils-2.21/bfd/coffcode.h	2011-04-18 13:26:00.021164165 +0200
@@ -658,7 +658,10 @@
 
   /* FIXME: There is no gas syntax to specify the debug section flag.  */
   if (is_dbg)
-      sec_flags = SEC_DEBUGGING | SEC_READONLY;
+    {
+      sec_flags &= (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD);
+      sec_flags |= SEC_DEBUGGING | SEC_READONLY;
+    }
 
   /* skip LOAD */
   /* READONLY later */
--- binutils-2.21/gas/dw2gencfi.c	2010-09-03 00:43:45.000000000 +0200
+++ binutils-2.21/gas/dw2gencfi.c	2011-04-18 13:26:00.022164145 +0200
@@ -76,6 +76,136 @@
 # define DWARF2_ADDR_SIZE(bfd) (bfd_arch_bits_per_address (bfd) / 8)
 #endif
 
+/* Private segment collection list.  */
+struct dwcfi_seg_list {
+  segT seg;
+  int subseg;
+  char *seg_name;
+};
+
+static struct hash_control *dwcfi_hash;
+
+/* 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,*dollar, *dot;
+  char *sname;
+
+  if (!seg)
+    name = "";
+  else
+    name = bfd_get_section_name (stdoutput, seg);
+
+  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;
+
+  sname = concat (base_name, name, NULL);
+
+  return sname;
+}
+
+/* Allocate a dwcfi_seg_list structure.  */
+static struct dwcfi_seg_list *
+alloc_debugseg_item (segT seg, int subseg, char *name)
+{
+  struct dwcfi_seg_list *r;
+
+  r = (struct dwcfi_seg_list *)
+    xmalloc (sizeof (struct dwcfi_seg_list) + strlen (name));
+  r->seg = seg;
+  r->subseg = subseg;
+  r->seg_name = name;
+  return r;
+}
+
+/* Generate debug... segment with same linkonce properties
+   of based segment.  */
+static segT
+make_debug_seg (segT cseg, char *name, int sflags)
+{
+  segT save_seg = now_seg;
+  int save_subseg = now_subseg;
+  segT r;
+  flagword flags;
+
+  r = subseg_new (name, 0);
+  /* Check if code segment is marked as linked once.  */
+  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);
+
+  /* Add standard section flags.  */
+  flags |= sflags;
+
+  /* Apply possibly linked once flags to new generated segment, too.  */
+  if (!bfd_set_section_flags (stdoutput, r, flags))
+    as_bad (_("bfd_set_section_flags: %s"),
+	    bfd_errmsg (bfd_get_error ()));
+
+  /* Restore to previous segment.  */
+  if (save_seg != NULL)
+    subseg_set (save_seg, save_subseg);
+  return r;
+}
+
+static void
+dwcfi_hash_insert (const char *name, struct dwcfi_seg_list *item)
+{
+  const char *error_string;
+
+  if ((error_string = hash_jam (dwcfi_hash, name, (char *) item)))
+    as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
+	      name, error_string);
+}
+
+static struct dwcfi_seg_list *
+dwcfi_hash_find (char *name)
+{
+  return (struct dwcfi_seg_list *) hash_find (dwcfi_hash, name);
+}
+
+static struct dwcfi_seg_list *
+dwcfi_hash_find_or_make (segT cseg, const char *base_name, int flags)
+{
+  struct dwcfi_seg_list *item;
+  char *name;
+
+  /* Initialize dwcfi_hash once.  */
+  if (!dwcfi_hash)
+    dwcfi_hash = hash_new ();
+
+  name = get_debugseg_name (cseg, base_name);
+
+  item = dwcfi_hash_find (name);
+  if (!item)
+    {
+      item = alloc_debugseg_item (make_debug_seg (cseg, name, flags), 0, name);
+
+      dwcfi_hash_insert (item->seg_name, item);
+    }
+  else
+    free (name);
+
+  return item;
+}
+
 /* ??? Share this with dwarf2cfg.c.  */
 #ifndef TC_DWARF2_EMIT_OFFSET
 #define TC_DWARF2_EMIT_OFFSET  generic_dwarf2_emit_offset
@@ -102,6 +232,7 @@
 struct cfi_insn_data
 {
   struct cfi_insn_data *next;
+  segT cur_seg;
   int insn;
   union {
     struct {
@@ -134,6 +265,7 @@
 struct fde_entry
 {
   struct fde_entry *next;
+  segT cseg;
   symbolS *start_address;
   symbolS *end_address;
   struct cfi_insn_data *data;
@@ -144,11 +276,13 @@
   expressionS lsda;
   unsigned int return_column;
   unsigned int signal_frame;
+  int handled;
 };
 
 struct cie_entry
 {
   struct cie_entry *next;
+  segT cur_seg;
   symbolS *start_address;
   unsigned int return_column;
   unsigned int signal_frame;
@@ -195,7 +329,8 @@
   frchain_now->frch_cfi_data->cur_fde_data = fde;
   *last_fde_data = fde;
   last_fde_data = &fde->next;
-
+  fde->cseg = now_seg;
+  fde->handled = 0;
   fde->last = &fde->data;
   fde->return_column = DWARF2_DEFAULT_RETURN_COLUMN;
   fde->per_encoding = DW_EH_PE_omit;
@@ -219,6 +354,7 @@
 
   *cur_fde_data->last = insn;
   cur_fde_data->last = &insn->next;
+  insn->cur_seg = now_seg;
 
   return insn;
 }
@@ -916,9 +1052,9 @@
 	name = input_line_pointer;
 	c = get_symbol_end ();
 
-	if (strcmp (name, ".eh_frame") == 0)
+	if (strncmp (name, ".eh_frame", 9) == 0)
 	  sections |= CFI_EMIT_eh_frame;
-	else if (strcmp (name, ".debug_frame") == 0)
+	else if (strncmp (name, ".debug_frame", 12) == 0)
 	  sections |= CFI_EMIT_debug_frame;
 	else
 	  {
@@ -1384,8 +1520,14 @@
     out_one (enc);
 
   if (cie->first)
+    {
     for (i = cie->first; i != cie->last; i = i->next)
+        {
+	  if (i->cur_seg != cie->cur_seg)
+	    continue;
       output_cfi_insn (i);
+	}
+    }
 
   frag_align (align, DW_CFA_nop, 0);
   symbol_set_value_now (end_address);
@@ -1492,7 +1634,10 @@
     }
 
   for (; first; first = first->next)
+    {
+      if (first->cur_seg == fde->cseg)
     output_cfi_insn (first);
+    }
 
   frag_align (align, DW_CFA_nop, 0);
   symbol_set_value_now (end_address);
@@ -1507,7 +1652,8 @@
 
   for (cie = cie_root; cie; cie = cie->next)
     {
-      if (cie->return_column != fde->return_column
+      if (cie->cur_seg != fde->cseg
+          || cie->return_column != fde->return_column
 	  || cie->signal_frame != fde->signal_frame
 	  || cie->per_encoding != fde->per_encoding
 	  || cie->lsda_encoding != fde->lsda_encoding)
@@ -1605,6 +1751,7 @@
   cie = (struct cie_entry *) xmalloc (sizeof (struct cie_entry));
   cie->next = cie_root;
   cie_root = cie;
+  cie->cur_seg = fde->cseg;
   cie->return_column = fde->return_column;
   cie->signal_frame = fde->signal_frame;
   cie->per_encoding = fde->per_encoding;
@@ -1629,9 +1776,12 @@
 
 #ifdef md_reg_eh_frame_to_debug_frame
 static void
-cfi_change_reg_numbers (struct cfi_insn_data *insn)
+cfi_change_reg_numbers (struct cfi_insn_data *insn, segT ccseg)
 {
   for (; insn; insn = insn->next)
+    {
+      if (insn->cur_seg != ccseg)
+        continue;
     switch (insn->insn)
       {
       case DW_CFA_advance_loc:
@@ -1667,42 +1817,73 @@
 	abort ();
       }
 }
+}
 #else
-#define cfi_change_reg_numbers(insn) do { } while (0)
+#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)
+{
+  struct dwcfi_seg_list *l;
+
+  l = dwcfi_hash_find_or_make (cseg, base, flags);
+
+  subseg_set (l->seg, l->subseg);
+  record_alignment (l->seg, align);
+  return l->seg;
+}
+
 void
 cfi_finish (void)
 {
-  segT cfi_seg;
+  struct cie_entry *cie, *cie_next;
+  segT cfi_seg, ccseg;
   struct fde_entry *fde;
-  int save_flag_traditional_format;
+  struct cfi_insn_data *first;
+  int save_flag_traditional_format, seek_next_seg;
 
   if (all_fde_data == 0)
     return;
 
   if ((cfi_sections & CFI_EMIT_eh_frame) != 0)
     {
-      /* Open .eh_frame section.  */
-      cfi_seg = subseg_new (".eh_frame", 0);
-      bfd_set_section_flags (stdoutput, cfi_seg,
-			     SEC_ALLOC | SEC_LOAD | SEC_DATA
-			     | DWARF2_EH_FRAME_READ_ONLY);
-      subseg_set (cfi_seg, 0);
-      record_alignment (cfi_seg, EH_FRAME_ALIGNMENT);
-
-#ifdef md_fix_up_eh_frame
-      md_fix_up_eh_frame (cfi_seg);
-#endif
-
       /* Make sure check_eh_frame doesn't do anything with our output.  */
       save_flag_traditional_format = flag_traditional_format;
       flag_traditional_format = 1;
 
+      do
+        {
+	  ccseg = NULL;
+	  cfi_seg = NULL;
+	  seek_next_seg = 0;
+	  for (cie = cie_root; cie; cie = cie_next)
+	    {
+	      cie_next = cie->next;
+	      free ((void *) cie);
+	    }
+	  cie_root = NULL;
+
       for (fde = all_fde_data; fde ; fde = fde->next)
 	{
-	  struct cfi_insn_data *first;
-	  struct cie_entry *cie;
+	      if (fde->handled != 0)
+	        continue;
+	      if (ccseg != NULL && fde->cseg != ccseg)
+	        continue;
+	      if (ccseg == NULL)
+	        {
+		  ccseg = fde->cseg;
+		  /* Open .eh_frame section.  */
+		  cfi_seg = get_cfi_seg (ccseg, ".eh_frame",
+					 SEC_ALLOC | SEC_LOAD | SEC_DATA
+					 | DWARF2_EH_FRAME_READ_ONLY,
+					 EH_FRAME_ALIGNMENT);
+#ifdef md_fix_up_eh_frame
+		  md_fix_up_eh_frame (cfi_seg);
+#endif
+		}
+	      fde->handled = 1;
+	      seek_next_seg = 1;
 
 	  if (fde->end_address == NULL)
 	    {
@@ -1714,15 +1895,24 @@
 	  output_fde (fde, cie, TRUE, first,
 		      fde->next == NULL ? EH_FRAME_ALIGNMENT : 2);
 	}
+	}
+      while (seek_next_seg != 0);
+
+      for (fde = all_fde_data; fde ; fde = fde->next)
+        fde->handled = 0;
 
       flag_traditional_format = save_flag_traditional_format;
     }
 
   if ((cfi_sections & CFI_EMIT_debug_frame) != 0)
     {
-      struct cie_entry *cie, *cie_next;
       int alignment = ffs (DWARF2_ADDR_SIZE (stdoutput)) - 1;
 
+      do
+        {
+	  ccseg = NULL;
+	  cfi_seg = NULL;
+	  seek_next_seg = 0;
       for (cie = cie_root; cie; cie = cie_next)
 	{
 	  cie_next = cie->next;
@@ -1730,17 +1920,22 @@
 	}
       cie_root = NULL;
 
-      /* Open .debug_frame section.  */
-      cfi_seg = subseg_new (".debug_frame", 0);
-      bfd_set_section_flags (stdoutput, cfi_seg,
-			     SEC_READONLY | SEC_DEBUGGING);
-      subseg_set (cfi_seg, 0);
-      record_alignment (cfi_seg, alignment);
-
       for (fde = all_fde_data; fde ; fde = fde->next)
 	{
-	  struct cfi_insn_data *first;
-
+	      if (fde->handled != 0)
+	        continue;
+	      if (ccseg != NULL && fde->cseg != ccseg)
+	        continue;
+	      if (ccseg == NULL)
+	        {
+		  ccseg = fde->cseg;
+		  /* Open .debug_frame section.  */
+		  cfi_seg = get_cfi_seg (ccseg, ".debug_frame",
+				     SEC_READONLY | SEC_DEBUGGING,
+				     alignment);
+		}
+	      fde->handled = 1;
+	      seek_next_seg = 1;
 	  if (fde->end_address == NULL)
 	    {
 	      as_bad (_("open CFI at the end of file; missing .cfi_endproc directive"));
@@ -1749,11 +1944,16 @@
 
 	  fde->per_encoding = DW_EH_PE_omit;
 	  fde->lsda_encoding = DW_EH_PE_omit;
-	  cfi_change_reg_numbers (fde->data);
+	      cfi_change_reg_numbers (fde->data, ccseg);
 	  cie = select_cie_for_fde (fde, FALSE, &first, alignment);
 	  output_fde (fde, cie, FALSE, first, alignment);
 	}
     }
+      while (seek_next_seg != 0);
+
+      for (fde = all_fde_data; fde ; fde = fde->next)
+        fde->handled = 0;
+    }
 }
 
 #else /* TARGET_USE_CFIPOP */
--- binutils-2.21/gas/ehopt.c	2009-09-11 17:27:33.000000000 +0200
+++ binutils-2.21/gas/ehopt.c	2011-04-18 13:26:00.023164125 +0200
@@ -120,7 +120,7 @@
 
   /* First make sure that the CIE Identifier Tag is 0/-1.  */
 
-  if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
+  if (strncmp (segment_name (now_seg), ".debug_frame", 12) == 0)
     CIE_id = (char)0xff;
   else
     CIE_id = 0;
@@ -285,9 +285,9 @@
 #endif
 
   /* Select the proper section data.  */
-  if (strcmp (segment_name (now_seg), ".eh_frame") == 0)
+  if (strncmp (segment_name (now_seg), ".eh_frame", 9) == 0)
     d = &eh_frame_data;
-  else if (strcmp (segment_name (now_seg), ".debug_frame") == 0)
+  else if (strncmp (segment_name (now_seg), ".debug_frame", 12) == 0)
     d = &debug_frame_data;
   else
     return 0;
--- binutils-2.21/ld/deffile.h	2009-10-23 13:40:17.000000000 +0200
+++ binutils-2.21/ld/deffile.h	2011-04-18 13:26:00.024164105 +0200
@@ -105,10 +105,10 @@
 extern void def_file_free (def_file *);
 extern def_file_export *def_file_add_export (def_file *, const char *,
 					     const char *, int,
-					     const char *);
+					     const char *, int *);
 extern def_file_import *def_file_add_import (def_file *, const char *,
 					     const char *, int, const char *,
-					     const char *);
+					     const char *, int *);
 extern void def_file_add_directive (def_file *, const char *, int);
 extern def_file_module *def_get_module (def_file *, const char *);
 #ifdef DEF_FILE_PRINT
--- binutils-2.21/ld/deffilep.y	2010-05-25 12:05:16.000000000 +0200
+++ binutils-2.21/ld/deffilep.y	2011-04-18 13:26:56.365073086 +0200
@@ -534,16 +534,105 @@
 }
 #endif
 
+/* Helper routine to check for identity of string pointers,
+   which might be NULL.  */
+
+static int
+are_names_equal (const char *s1, const char *s2)
+{
+  if (!s1 && !s2)
+    return 0;
+  if (!s1 || !s2)
+    return (!s1 ? -1 : 1);
+  return strcmp (s1, s2);
+}
+
+static int
+cmp_export_elem (const def_file_export *e, const char *ex_name,
+		 const char *in_name, const char *its_name,
+		 int ord)
+{
+  int r;
+
+  if ((r = are_names_equal (ex_name, e->name)) != 0)
+    return r;
+  if ((r = are_names_equal (in_name, e->internal_name)) != 0)
+    return r;
+  if ((r = are_names_equal (its_name, e->its_name)) != 0)
+    return r;
+  return (ord - e->ordinal);
+}
+
+/* Search the position of the identical element, or returns the position
+   of the next higher element. If last valid element is smaller, then MAX
+   is returned.  */
+
+static int
+find_export_in_list (def_file_export *b, int max,
+		     const char *ex_name, const char *in_name,
+		     const char *its_name, int ord, int *is_ident)
+{
+  int e, l, r, p;
+
+  *is_ident = 0;
+  if (!max)
+    return 0;
+  if ((e = cmp_export_elem (b, ex_name, in_name, its_name, ord)) <= 0)
+    return 0;
+  if (max == 1)
+    return 1;
+  if ((e = cmp_export_elem (b + (max - 1), ex_name, in_name, its_name, ord)) > 0)
+    return max;
+  else if (!e || max == 2)
+    return max - 1;
+  l = 0; r = max - 1;
+  while (l < r)
+    {
+      p = (l + r) / 2;
+      e = cmp_export_elem (b + p, ex_name, in_name, its_name, ord);
+      if (!e)
+        {
+          *is_ident = 1;
+          return p;
+        }
+      else if (e < 0)
+        r = p - 1;
+      else if (e > 0)
+        l = p + 1;
+    }
+  if ((e = cmp_export_elem (b + l, ex_name, in_name, its_name, ord)) > 0)
+    ++l;
+  else if (!e)
+    *is_ident = 1;
+  return l;
+}
+
 def_file_export *
 def_file_add_export (def_file *fdef,
 		     const char *external_name,
 		     const char *internal_name,
 		     int ordinal,
-		     const char *its_name)
+		     const char *its_name,
+		     int *is_dup)
 {
   def_file_export *e;
+  int pos;
   int max_exports = ROUND_UP(fdef->num_exports, 32);
 
+  if (internal_name && !external_name)
+    external_name = internal_name;
+  if (external_name && !internal_name)
+    internal_name = external_name;
+
+  /* We need to avoid duplicates.  */
+  *is_dup = 0;
+  pos = find_export_in_list (fdef->exports, fdef->num_exports,
+		     external_name, internal_name,
+		     its_name, ordinal, is_dup);
+
+  if (*is_dup != 0)
+    return (fdef->exports + pos);
+
   if (fdef->num_exports >= max_exports)
     {
       max_exports = ROUND_UP(fdef->num_exports + 1, 32);
@@ -553,12 +642,11 @@
       else
 	fdef->exports = xmalloc (max_exports * sizeof (def_file_export));
     }
-  e = fdef->exports + fdef->num_exports;
+
+  e = fdef->exports + pos;
+  if (pos != fdef->num_exports)
+    memmove (&e[1], e, (sizeof (def_file_export) * (fdef->num_exports - pos)));
   memset (e, 0, sizeof (def_file_export));
-  if (internal_name && !external_name)
-    external_name = internal_name;
-  if (external_name && !internal_name)
-    internal_name = external_name;
   e->name = xstrdup (external_name);
   e->internal_name = xstrdup (internal_name);
   e->its_name = (its_name ? xstrdup (its_name) : NULL);
@@ -594,17 +682,88 @@
   return s;
 }
 
+static int
+cmp_import_elem (const def_file_import *e, const char *ex_name,
+		 const char *in_name, const char *module,
+		 int ord)
+{
+  int r;
+
+  if ((r = are_names_equal (ex_name, e->name)) != 0)
+    return r;
+  if ((r = are_names_equal (in_name, e->internal_name)) != 0)
+    return r;
+  if (ord != e->ordinal)
+    return (ord < e->ordinal ? -1 : 1);
+  return are_names_equal (module, (e->module ? e->module->name : NULL));
+}
+
+/* Search the position of the identical element, or returns the position
+   of the next higher element. If last valid element is smaller, then MAX
+   is returned.  */
+
+static int
+find_import_in_list (def_file_import *b, int max,
+		     const char *ex_name, const char *in_name,
+		     const char *module, int ord, int *is_ident)
+{
+  int e, l, r, p;
+
+  *is_ident = 0;
+  if (!max)
+    return 0;
+  if ((e = cmp_import_elem (b, ex_name, in_name, module, ord)) <= 0)
+    return 0;
+  if (max == 1)
+    return 1;
+  if ((e = cmp_import_elem (b + (max - 1), ex_name, in_name, module, ord)) > 0)
+    return max;
+  else if (!e || max == 2)
+    return max - 1;
+  l = 0; r = max - 1;
+  while (l < r)
+    {
+      p = (l + r) / 2;
+      e = cmp_import_elem (b + p, ex_name, in_name, module, ord);
+      if (!e)
+        {
+          *is_ident = 1;
+          return p;
+        }
+      else if (e < 0)
+        r = p - 1;
+      else if (e > 0)
+        l = p + 1;
+    }
+  if ((e = cmp_import_elem (b + l, ex_name, in_name, module, ord)) > 0)
+    ++l;
+  else if (!e)
+    *is_ident = 1;
+  return l;
+}
+
 def_file_import *
 def_file_add_import (def_file *fdef,
 		     const char *name,
 		     const char *module,
 		     int ordinal,
 		     const char *internal_name,
-		     const char *its_name)
+		     const char *its_name,
+		     int *is_dup)
 {
   def_file_import *i;
+  int pos;
   int max_imports = ROUND_UP (fdef->num_imports, 16);
 
+  /* We need to avoid here duplicates.  */
+  *is_dup = 0;
+  pos = find_import_in_list (fdef->imports, fdef->num_imports,
+			     name,
+			     (!internal_name ? name : internal_name),
+			     module, ordinal, is_dup);
+  if (*is_dup != 0)
+    return fdef->imports + pos;
+
   if (fdef->num_imports >= max_imports)
     {
       max_imports = ROUND_UP (fdef->num_imports+1, 16);
@@ -615,7 +774,9 @@
       else
 	fdef->imports = xmalloc (max_imports * sizeof (def_file_import));
     }
-  i = fdef->imports + fdef->num_imports;
+  i = fdef->imports + pos;
+  if (pos != fdef->num_imports)
+    memmove (&i[1], i, (sizeof (def_file_import) * (fdef->num_imports - pos)));
   memset (i, 0, sizeof (def_file_import));
   if (name)
     i->name = xstrdup (name);
@@ -849,6 +1010,7 @@
 	     const char *its_name)
 {
   def_file_export *dfe;
+  int is_dup = 0;
 
   if (!internal_name && external_name)
     internal_name = external_name;
@@ -857,7 +1019,13 @@
 #endif
 
   dfe = def_file_add_export (def, external_name, internal_name, ordinal,
-  							 its_name);
+			     its_name, &is_dup);
+
+  /* We might check here for flag redefinition and warn.  For now we
+     ignore duplicates silently.  */
+  if (is_dup)
+    return;
+
   if (flags & 1)
     dfe->flag_noname = 1;
   if (flags & 2)
@@ -878,13 +1046,14 @@
 {
   char *buf = 0;
   const char *ext = dllext ? dllext : "dll";    
+  int is_dup = 0;
    
   buf = xmalloc (strlen (module) + strlen (ext) + 2);
   sprintf (buf, "%s.%s", module, ext);
   module = buf;
 
-  def_file_add_import (def, name, module, ordinal, internal_name, its_name);
-  if (buf)
+  def_file_add_import (def, name, module, ordinal, internal_name, its_name,
+		       &is_dup);
     free (buf);
 }
 
@@ -909,14 +1078,40 @@
 static void
 def_aligncomm (char *str, int align)
 {
-  def_file_aligncomm *c = xmalloc (sizeof (def_file_aligncomm));
+  def_file_aligncomm *c, *p;
 
+  p = NULL;
+  c = def->aligncomms;
+  while (c != NULL)
+    {
+      int e = strcmp (c->symbol_name, str);
+      if (!e)
+	{
+	  /* Not sure if we want to allow here duplicates with
+	     different alignments, but for now we keep them.  */
+	  e = (int) c->alignment - align;
+	  if (!e)
+	    return;
+	}
+      if (e > 0)
+        break;
+      c = (p = c)->next;
+    }
+
+  c = xmalloc (sizeof (def_file_aligncomm));
   c->symbol_name = xstrdup (str);
   c->alignment = (unsigned int) align;
-
+  if (!p)
+    {
   c->next = def->aligncomms;
   def->aligncomms = c;
 }
+  else
+    {
+      c->next = p->next;
+      p->next = c;
+    }
+}
 
 static int
 def_error (const char *err)
--- binutils-2.21/ld/pe-dll.c	2010-06-27 06:07:54.000000000 +0200
+++ binutils-2.21/ld/pe-dll.c	2011-04-18 13:26:00.027164048 +0200
@@ -751,9 +751,12 @@
 
 		  if (auto_export (b, pe_def_file, sn))
 		    {
+		      int is_dup = 0;
 		      def_file_export *p;
-		      p=def_file_add_export (pe_def_file, sn, 0, -1, NULL);
+		      p = def_file_add_export (pe_def_file, sn, 0, -1,
+					       NULL, &is_dup);
 		      /* Fill data flag properly, from dlltool.c.  */
+		      if (!is_dup)
 		      p->flag_data = !(symbols[j]->flags & BSF_FUNCTION);
 		    }
 		}
@@ -801,6 +804,7 @@
 
 	  if (strchr (pe_def_file->exports[i].name, '@'))
 	    {
+	      int is_dup = 1;
 	      int lead_at = (*pe_def_file->exports[i].name == '@');
 	      char *tmp = xstrdup (pe_def_file->exports[i].name + lead_at);
 
@@ -808,8 +812,8 @@
 	      if (auto_export (NULL, pe_def_file, tmp))
 		def_file_add_export (pe_def_file, tmp,
 				     pe_def_file->exports[i].internal_name,
-				     -1, NULL);
-	      else
+				     -1, NULL, &is_dup);
+	      if (is_dup)
 		free (tmp);
 	    }
 	}
@@ -3146,6 +3150,7 @@
 	 exported in buggy auto-import releases.  */
       if (! CONST_STRNEQ (erva + name_rva, "__nm_"))
  	{
+	  int is_dup = 0;
  	  /* is_data is true if the address is in the data, rdata or bss
 	     segment.  */
  	  is_data =
@@ -3154,8 +3159,9 @@
 	    || (func_rva >= bss_start && func_rva < bss_end);
 
 	  imp = def_file_add_import (pe_def_file, erva + name_rva,
-				     dllname, i, 0, NULL);
+				     dllname, i, 0, NULL, &is_dup);
  	  /* Mark symbol type.  */
+ 	  if (!is_dup)
  	  imp->data = is_data;
 
  	  if (pe_dll_extra_pe_debug)
--- binutils-2.21/ld/scripttempl/pep.sc	2010-11-04 17:03:25.000000000 +0100
+++ binutils-2.21/ld/scripttempl/pep.sc	2011-04-18 13:26:00.028164029 +0200
@@ -116,7 +116,7 @@
 
   .eh_frame ${RELOCATING+BLOCK(__section_alignment__)} :
   {
-    *(.eh_frame)
+    *(.eh_frame*)
   }
 
   .pdata ${RELOCATING+BLOCK(__section_alignment__)} :
@@ -256,7 +256,7 @@
 
   .debug_frame ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_frame)
+    *(.debug_frame*)
   }
 
   .debug_str ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
@@ -271,40 +271,40 @@
 
   .debug_macinfo ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_macinfo)
+    *(.debug_macinfo*)
   }
 
   /* SGI/MIPS DWARF 2 extensions.  */
   .debug_weaknames ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_weaknames)
+    *(.debug_weaknames*)
   }
 
   .debug_funcnames ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_funcnames)
+    *(.debug_funcnames*)
   }
 
   .debug_typenames ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_typenames)
+    *(.debug_typenames*)
   }
 
   .debug_varnames ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_varnames)
+    *(.debug_varnames*)
   }
 
   /* DWARF 3.  */
   .debug_ranges ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_ranges)
+    *(.debug_ranges*)
   }
 
   /* DWARF 4.  */
   .debug_types ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_types) *(.gnu.linkonce.wt.*)
+    *(.debug_types*) *(.gnu.linkonce.wt.*)
   }
 }
 EOF
--- binutils-2.21/ld/scripttempl/pe.sc	2010-11-04 17:03:24.000000000 +0100
+++ binutils-2.21/ld/scripttempl/pe.sc	2011-04-18 13:26:00.029164010 +0200
@@ -115,7 +115,7 @@
 
   .eh_frame ${RELOCATING+BLOCK(__section_alignment__)} :
   {
-    *(.eh_frame)
+    *(.eh_frame) *(.eh_frame\$*) *(.eh_frame.*)
   }
 
   .pdata ${RELOCATING+BLOCK(__section_alignment__)} :
@@ -250,7 +250,7 @@
 
   .debug_frame ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :
   {
-    *(.debug_frame)
+    *(.debug_frame*)
   }
 
   .debug_str ${RELOCATING+BLOCK(__section_alignment__)} ${RELOCATING+(NOLOAD)} :

Places

File binutils-2.21-oom.patch of Package mingw64-binutils (Revision bf68ac044fd09ec28ea3c81af8ba09ac)

Places