2012-01-07 Juan Manuel Guerrero  <juan.guerrero@gmx.de>

	* bfd/coff-go32.c: Define COFF_GO32 macro.
	Add _bfd_go32_mkobject prototype.
	Define coff_mkobject macro to _bfd_go32_mkobject.
	Define IMAGE_SCN_LNK_NRELOC_OVFL.  Signals that reloc counter has
	overflown.
	Define PUT_SCNHDR_NLNNO_EXTENDED and PUT_SCNHDR_NRELOC_EXTENDED macros.
	Define GET_SCNHDR_NLNNO_EXTENDED and GET_SCNHDR_NRELOC_EXTENDED macros.

	* bfd/coff-stgo32.c: Add _bfd_go32_mkobject prototype.
	Define coff_mkobject macro to _bfd_go32_mkobject.
	Add _bfd_go32_mkobject definition.
	Define IMAGE_SCN_LNK_NRELOC_OVFL.  Signals that reloc counter has
	overflown.
	Define PUT_SCNHDR_NLNNO_EXTENDED and PUT_SCNHDR_NRELOC_EXTENDED macros.
	Define GET_SCNHDR_NLNNO_EXTENDED and GET_SCNHDR_NRELOC_EXTENDED macros.

	* bfd/coffswap.h (coff_swap_scnhdr_out) [COFF_GO32_EXE, COFF_GO32]:
	Use PUT_SCNHDR_NLNNO_EXTENDED, PUT_SCNHDR_NRELOC_EXTENDED,
	GET_SCNHDR_NLNNO_EXTENDED and GET_SCNHDR_NRELOC_EXTENDED macros to
	support line und reloc counters larger than 65535.

	* bfd/coffcode.h [COFF_GO32_EXE, COFF_GO32, COFF_WITH_PE]: Define new
	macro COFF_WITH_EXTENDED_RELOC_COUNTER.
	(coff_write_relocs, coff_write_object_contents): Replace COFF_WITH_PE
	with COFF_WITH_EXTENDED_RELOC_COUNTER where appropriate and add
	obj_go32 to the check if counter >= 0xFFFF.
	(coff_set_alignment_hook): Implementation for DJGPP.
	[COFF_GO32_EXE, COFF_GO32]:  Define COFF_PAD_SECTION_HEADERS.
	Taken from bnu219s2.zip.

	* bfd/libcoff-in.h: Define obj_go32 macro.
	Add go32 flag to struct coff_tdata.  1 if DJGPP else 0.

	* bfd/cofflink.c (_bfd_coff_final_link): If it is an obj_go32 allow
	relocations larger than 65535.

	* config.sub:  Use uname result to set basic_machine value
	instead of hardcoded one.

	* djgpp/bfdsymify/ChangeLog:  File taken from the previous
	gdb port to djgpp.

	* djgpp/bfdsymify/Makefile:  File taken from the previous
	gdb port to djgpp.  Adapted to this port version.

	* djgpp/bfdsymify/bfdsymify.c:  File taken from the previous
	gdb port to djgpp.

	* djgpp/bfdsymify/readme:  File taken from the previous gdb
	port to djgpp.

	* djgpp/build.sh:  DJGPP specific shell script to adjust, configure
	and compile progs and libs.

	* libiberty/make-relative-prefix.c:  DJGPP specific adjustments.
	Taken from bnu219s2.zip.

	* libiberty/make-temp-file.c:  DJGPP specific adjustments.
	Taken from bnu219s2.zip.






diff -aprNU5 gdb-7.3.1.orig/bfd/coff-go32.c gdb-7.3.1/bfd/coff-go32.c
--- gdb-7.3.1.orig/bfd/coff-go32.c	2009-09-02 07:18:36 +0000
+++ gdb-7.3.1/bfd/coff-go32.c	2012-01-08 00:21:28 +0000
@@ -21,10 +21,11 @@
    MA 02110-1301, USA.  */
 
 #define TARGET_SYM		go32coff_vec
 #define TARGET_NAME		"coff-go32"
 #define TARGET_UNDERSCORE	'_'
+#define COFF_GO32
 #define COFF_LONG_SECTION_NAMES
 #define COFF_SUPPORT_GNU_LINKONCE
 #define COFF_LONG_FILENAMES
 
 #define COFF_SECTION_ALIGNMENT_ENTRIES \
@@ -41,6 +42,98 @@
 { COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
 { COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi"), \
   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }
 
+/* Section contains extended relocations. */
+#define IMAGE_SCN_LNK_NRELOC_OVFL  0x01000000
+
+#define PUT_SCNHDR_NLNNO_EXTENDED(abdf, scnhdr_int, scnhdr_ext)                    \
+  do {                                                                             \
+    if (coff_data (abfd)->link_info                                                \
+        && strcmp (scnhdr_int->s_name, ".text") == 0)                              \
+      {                                                                            \
+        /* By inference from looking at MS output, the 32 bit field                \
+           which is the combination of the number_of_relocs and                    \
+           number_of_linenos is used for the line number count in                  \
+           executables.  A 16-bit field won't do for cc1.  The MS                  \
+           document says that the number of relocs is zero for                     \
+           executables, but the 17-th bit has been observed to be there.           \
+           Overflow is not an issue: a 4G-line program will overflow a             \
+           bunch of other fields long before this!  */                             \
+        H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);      \
+        H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);        \
+      }                                                                            \
+    else                                                                           \
+      {                                                                            \
+        if (scnhdr_int->s_nlnno <= 0xffff)                                         \
+          H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);               \
+        else                                                                       \
+          {                                                                        \
+            (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),  \
+                                   bfd_get_filename (abfd),                        \
+                                   scnhdr_int->s_nlnno);                           \
+            bfd_set_error (bfd_error_file_truncated);                              \
+            H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);                          \
+            ret = 0;                                                               \
+          }                                                                        \
+      }                                                                            \
+  } while (0)
+
+#define PUT_SCNHDR_NRELOC_EXTENDED(abdf, scnhdr_int, scnhdr_ext)                   \
+  do {                                                                             \
+    if (!coff_data (abfd)->link_info                                               \
+        || strcmp (scnhdr_int->s_name, ".text") != 0)                              \
+      {                                                                            \
+        /* Although we could encode 0xffff relocs here, we do not, to be           \
+           consistent with other parts of bfd. Also it lets us warn, as            \
+           we should never see 0xffff here w/o having the overflow flag            \
+           set.  */                                                                \
+        if (scnhdr_int->s_nreloc < 0xffff)                                         \
+          H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);             \
+        else                                                                       \
+          {                                                                        \
+            /* DJGPP can deal with large #s of relocs, but not here.  */           \
+            H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);                         \
+            scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;                      \
+            H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);             \
+          }                                                                        \
+      }                                                                            \
+  } while (0)
+
+#define GET_SCNHDR_NLNNO_EXTENDED(abfd, scnhdr_ext)                                \
+  ({                                                                               \
+      /* MS handles overflow of line numbers by carrying into the reloc            \
+         field (it appears).  Since it's supposed to be zero for PE                \
+         *IMAGE* format, that's safe.  This is still a bit iffy.  */               \
+                                                                                   \
+      unsigned short _s_nlnno;                                                     \
+      coff_data_type *_coff = coff_data (abfd);                                    \
+                                                                                   \
+      if (_coff->go32stub)                                                         \
+        _s_nlnno = (H_GET_16 (abfd, scnhdr_ext->s_nlnno)                           \
+                      + (H_GET_16 (abfd, scnhdr_ext->s_nreloc) << 16));            \
+      else                                                                         \
+        _s_nlnno = H_GET_16 (abfd, scnhdr_ext->s_nlnno);                           \
+      _s_nlnno;                                                                    \
+  })
+
+#define GET_SCNHDR_NRELOC_EXTENDED(abfd, scnhdr_ext)                               \
+  ({                                                                               \
+      /* MS handles overflow of line numbers by carrying into the reloc            \
+         field (it appears).  Since it's supposed to be zero for PE                \
+         *IMAGE* format, that's safe.  This is still a bit iffy.  */               \
+                                                                                   \
+      unsigned short _s_nreloc;                                                    \
+      coff_data_type *_coff = coff_data (abfd);                                    \
+                                                                                   \
+      _s_nreloc = _coff->go32stub ? 0 : H_GET_16 (abfd, scnhdr_ext->s_nreloc);     \
+      _s_nreloc;                                                                   \
+  })
+
+#include "bfd.h"
+
+bfd_boolean _bfd_go32_mkobject (bfd *abfd);
+
+#define coff_mkobject  _bfd_go32_mkobject
+
 #include "coff-i386.c"
diff -aprNU5 gdb-7.3.1.orig/bfd/coff-stgo32.c gdb-7.3.1/bfd/coff-stgo32.c
--- gdb-7.3.1.orig/bfd/coff-stgo32.c	2009-09-05 07:56:20 +0000
+++ gdb-7.3.1/bfd/coff-stgo32.c	2012-01-08 00:21:28 +0000
@@ -52,10 +52,96 @@
 { COFF_SECTION_NAME_PARTIAL_MATCH (".debug"), \
   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }, \
 { COFF_SECTION_NAME_PARTIAL_MATCH (".gnu.linkonce.wi"), \
   COFF_ALIGNMENT_FIELD_EMPTY, COFF_ALIGNMENT_FIELD_EMPTY, 0 }
 
+/* Section contains extended relocations. */
+#define IMAGE_SCN_LNK_NRELOC_OVFL  0x01000000
+
+#define PUT_SCNHDR_NLNNO_EXTENDED(abdf, scnhdr_int, scnhdr_ext)                    \
+  do {                                                                             \
+    if (coff_data (abfd)->link_info                                                \
+        && strcmp (scnhdr_int->s_name, ".text") == 0)                              \
+      {                                                                            \
+        /* By inference from looking at MS output, the 32 bit field                \
+           which is the combination of the number_of_relocs and                    \
+           number_of_linenos is used for the line number count in                  \
+           executables.  A 16-bit field won't do for cc1.  The MS                  \
+           document says that the number of relocs is zero for                     \
+           executables, but the 17-th bit has been observed to be there.           \
+           Overflow is not an issue: a 4G-line program will overflow a             \
+           bunch of other fields long before this!  */                             \
+        H_PUT_16 (abfd, (scnhdr_int->s_nlnno & 0xffff), scnhdr_ext->s_nlnno);      \
+        H_PUT_16 (abfd, (scnhdr_int->s_nlnno >> 16), scnhdr_ext->s_nreloc);        \
+      }                                                                            \
+    else                                                                           \
+      {                                                                            \
+        if (scnhdr_int->s_nlnno <= 0xffff)                                         \
+          H_PUT_16 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);               \
+        else                                                                       \
+          {                                                                        \
+            (*_bfd_error_handler) (_("%s: line number overflow: 0x%lx > 0xffff"),  \
+                                   bfd_get_filename (abfd),                        \
+                                   scnhdr_int->s_nlnno);                           \
+            bfd_set_error (bfd_error_file_truncated);                              \
+            H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nlnno);                          \
+            ret = 0;                                                               \
+          }                                                                        \
+      }                                                                            \
+  } while (0)
+
+#define PUT_SCNHDR_NRELOC_EXTENDED(abdf, scnhdr_int, scnhdr_ext)                   \
+  do {                                                                             \
+    if (!coff_data (abfd)->link_info                                               \
+        || strcmp (scnhdr_int->s_name, ".text") != 0)                              \
+      {                                                                            \
+        /* Although we could encode 0xffff relocs here, we do not, to be           \
+           consistent with other parts of bfd. Also it lets us warn, as            \
+           we should never see 0xffff here w/o having the overflow flag            \
+           set.  */                                                                \
+        if (scnhdr_int->s_nreloc < 0xffff)                                         \
+          H_PUT_16 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);             \
+        else                                                                       \
+          {                                                                        \
+            /* DJGPP can deal with large #s of relocs, but not here.  */           \
+            H_PUT_16 (abfd, 0xffff, scnhdr_ext->s_nreloc);                         \
+            scnhdr_int->s_flags |= IMAGE_SCN_LNK_NRELOC_OVFL;                      \
+            H_PUT_32 (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);             \
+          }                                                                        \
+      }                                                                            \
+  } while (0)
+
+#define GET_SCNHDR_NLNNO_EXTENDED(abfd, scnhdr_ext)                                \
+  ({                                                                               \
+      /* MS handles overflow of line numbers by carrying into the reloc            \
+         field (it appears).  Since it's supposed to be zero for PE                \
+         *IMAGE* format, that's safe.  This is still a bit iffy.  */               \
+                                                                                   \
+      unsigned short _s_nlnno;                                                     \
+      coff_data_type *_coff = coff_data (abfd);                                    \
+                                                                                   \
+      if (_coff->go32stub)                                                         \
+        _s_nlnno = (H_GET_16 (abfd, scnhdr_ext->s_nlnno)                           \
+                      + (H_GET_16 (abfd, scnhdr_ext->s_nreloc) << 16));            \
+      else                                                                         \
+        _s_nlnno = H_GET_16 (abfd, scnhdr_ext->s_nlnno);                           \
+      _s_nlnno;                                                                    \
+  })
+
+#define GET_SCNHDR_NRELOC_EXTENDED(abfd, scnhdr_ext)                               \
+  ({                                                                               \
+      /* MS handles overflow of line numbers by carrying into the reloc            \
+         field (it appears).  Since it's supposed to be zero for PE                \
+         *IMAGE* format, that's safe.  This is still a bit iffy.  */               \
+                                                                                   \
+      unsigned short _s_nreloc;                                                    \
+      coff_data_type *_coff = coff_data (abfd);                                    \
+                                                                                   \
+      _s_nreloc = _coff->go32stub ? 0 : H_GET_16 (abfd, scnhdr_ext->s_nreloc);     \
+      _s_nreloc;                                                                   \
+  })
+
 #include "bfd.h"
 
 /* At first the prototypes.  */
 
 static void
@@ -98,10 +184,14 @@ create_go32_stub PARAMS ((bfd *));
 static bfd_boolean
   go32_stubbed_coff_bfd_copy_private_bfd_data PARAMS ((bfd *, bfd *));
 
 #define coff_bfd_copy_private_bfd_data go32_stubbed_coff_bfd_copy_private_bfd_data
 
+bfd_boolean _bfd_go32_mkobject (bfd *abfd);
+
+#define coff_mkobject  _bfd_go32_mkobject
+
 #include "coff-i386.c"
 
 /* This macro is used, because I cannot assume the endianess of the
    host system.  */
 #define _H(index) (H_GET_16 (abfd, (header+index*2)))
@@ -412,5 +502,29 @@ go32_stubbed_coff_bfd_copy_private_bfd_d
     memcpy (coff_data (obfd)->go32stub, coff_data (ibfd)->go32stub,
 	    GO32_STUBSIZE);
 
   return TRUE;
 }
+
+/*  This function is not static because it is used
+    by both targets coff-go32 and coff-go32-exe.  */
+
+bfd_boolean
+_bfd_go32_mkobject (bfd *abfd)
+{
+  coff_data_type *coff;
+  bfd_size_type amt = sizeof (coff_data_type);
+
+  abfd->tdata.coff_obj_data = bfd_zalloc (abfd, amt);
+  if (abfd->tdata.coff_obj_data == NULL)
+    return FALSE;
+  coff = coff_data (abfd);
+  coff->symbols = NULL;
+  coff->conversion_table = NULL;
+  coff->raw_syments = NULL;
+  coff->relocbase = 0;
+  coff->local_toc_sym_map = 0;
+
+  coff->go32 = 1;
+
+  return TRUE;
+}
diff -aprNU5 gdb-7.3.1.orig/bfd/coffcode.h gdb-7.3.1/bfd/coffcode.h
--- gdb-7.3.1.orig/bfd/coffcode.h	2011-03-31 08:13:48 +0000
+++ gdb-7.3.1/bfd/coffcode.h	2012-01-08 00:21:28 +0000
@@ -374,10 +374,14 @@ CODE_FRAGMENT
 #define DOT_DEBUG	".debug"
 #define GNU_LINKONCE_WI ".gnu.linkonce.wi."
 #define GNU_LINKONCE_WT ".gnu.linkonce.wt."
 #define DOT_RELOC	".reloc"
 
+#if defined(COFF_WITH_PE) || defined(COFF_GO32_EXE) || defined(COFF_GO32)
+# define COFF_WITH_EXTENDED_RELOC_COUNTER
+#endif
+
 #if defined (COFF_LONG_SECTION_NAMES)
 /* Needed to expand the inputs to BLANKOR1TOODD.  */
 #define COFFLONGSECTIONCATHELPER(x,y)    x ## y
 /* If the input macro Y is blank or '1', return an odd number; if it is
    '0', return an even number.  Result undefined in all other cases.  */
@@ -1909,13 +1913,50 @@ coff_set_alignment_hook (bfd *abfd, asec
     }
 }
 
 #else /* ! RS6000COFF_C */
 
+#if defined (COFF_GO32_EXE) || defined (COFF_GO32)
+
+static void
+coff_set_alignment_hook (bfd * abfd ATTRIBUTE_UNUSED,
+			 asection * section,
+			 void * scnhdr)
+{
+  struct internal_scnhdr *hdr = (struct internal_scnhdr *) scnhdr;
+
+  /* Check for extended relocs.  */
+  if (hdr->s_flags & IMAGE_SCN_LNK_NRELOC_OVFL)
+    {
+      struct external_reloc dst;
+      struct internal_reloc n;
+      file_ptr oldpos = bfd_tell (abfd);
+      bfd_size_type relsz = bfd_coff_relsz (abfd);
+
+      if (bfd_seek (abfd, (file_ptr) hdr->s_relptr, 0) != 0)
+	return;
+      if (bfd_bread (& dst, relsz, abfd) != relsz)
+	return;
+
+      coff_swap_reloc_in (abfd, &dst, &n);
+      if (bfd_seek (abfd, oldpos, 0) != 0)
+	return;
+      section->reloc_count = hdr->s_nreloc = n.r_vaddr - 1;
+      section->rel_filepos += relsz;
+    }
+  else if (hdr->s_nreloc == 0xffff)
+    (*_bfd_error_handler)
+      ("%s: warning: claims to have 0xffff relocs, without overflow",
+       bfd_get_filename (abfd));
+}
+
+#else /* ! COFF_GO32_EXE && ! COFF_GO32 */
+
 #define coff_set_alignment_hook \
   ((void (*) (bfd *, asection *, void *)) bfd_void)
 
+#endif /* ! COFF_GO32_EXE && ! COFF_GO32 */
 #endif /* ! RS6000COFF_C */
 #endif /* ! COFF_WITH_PE */
 #endif /* ! COFF_ALIGN_IN_SECTION_HEADER */
 
 #ifndef coff_mkobject
@@ -2621,12 +2662,12 @@ coff_write_relocs (bfd * abfd, int first
 #endif
 
       if (bfd_seek (abfd, s->rel_filepos, SEEK_SET) != 0)
 	return FALSE;
 
-#ifdef COFF_WITH_PE
-      if (obj_pe (abfd) && s->reloc_count >= 0xffff)
+#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
+      if ((obj_pe (abfd) || obj_go32 (abfd)) && s->reloc_count >= 0xffff)
 	{
 	  /* Encode real count here as first reloc.  */
 	  struct internal_reloc n;
 
 	  memset (& n, 0, sizeof (n));
@@ -3568,13 +3609,13 @@ coff_write_object_contents (bfd * abfd)
   /* Work out the size of the reloc and linno areas.  */
 
   for (current = abfd->sections; current != NULL; current =
        current->next)
     {
-#ifdef COFF_WITH_PE
+#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
       /* We store the actual reloc count in the first reloc's addr.  */
-      if (obj_pe (abfd) && current->reloc_count >= 0xffff)
+      if ((obj_pe (abfd) || obj_go32 (abfd)) && current->reloc_count >= 0xffff)
 	reloc_count ++;
 #endif
       reloc_count += current->reloc_count;
     }
 
@@ -3598,13 +3639,13 @@ coff_write_object_contents (bfd * abfd)
 
       if (current->reloc_count)
 	{
 	  current->rel_filepos = reloc_base;
 	  reloc_base += current->reloc_count * bfd_coff_relsz (abfd);
-#ifdef COFF_WITH_PE
+#ifdef COFF_WITH_EXTENDED_RELOC_COUNTER
 	  /* Extra reloc to hold real count.  */
-	  if (obj_pe (abfd) && current->reloc_count >= 0xffff)
+	  if ((obj_pe (abfd) || obj_go32 (abfd)) && current->reloc_count >= 0xffff)
 	    reloc_base += bfd_coff_relsz (abfd);
 #endif
 	}
       else
 	current->rel_filepos = 0;
diff -aprNU5 gdb-7.3.1.orig/bfd/cofflink.c gdb-7.3.1/bfd/cofflink.c
--- gdb-7.3.1.orig/bfd/cofflink.c	2010-12-13 01:06:14 +0000
+++ gdb-7.3.1/bfd/cofflink.c	2012-01-08 00:21:28 +0000
@@ -761,11 +761,11 @@ _bfd_coff_final_link (bfd *abfd,
 	  o->flags |= SEC_RELOC;
 	  o->rel_filepos = rel_filepos;
 	  rel_filepos += o->reloc_count * relsz;
 	  /* In PE COFF, if there are at least 0xffff relocations an
 	     extra relocation will be written out to encode the count.  */
-	  if (obj_pe (abfd) && o->reloc_count >= 0xffff)
+	  if ((obj_pe (abfd) || obj_go32 (abfd)) && o->reloc_count >= 0xffff)
 	    rel_filepos += relsz;
 	}
 
       if (bfd_coff_long_section_names (abfd)
 	  && strlen (o->name) > SCNNMLEN)
@@ -1065,11 +1065,11 @@ _bfd_coff_final_link (bfd *abfd,
 	      bfd_coff_swap_reloc_out (abfd, irel, erel);
 	    }
 
 	  if (bfd_seek (abfd, o->rel_filepos, SEEK_SET) != 0)
 	    goto error_return;
-	  if (obj_pe (abfd) && o->reloc_count >= 0xffff)
+	  if ((obj_pe (abfd) || obj_go32 (abfd)) && o->reloc_count >= 0xffff)
 	    {
 	      /* In PE COFF, write the count of relocs as the first
 		 reloc.  The header overflow bit will be set
 		 elsewhere. */
 	      struct internal_reloc incount;
diff -aprNU5 gdb-7.3.1.orig/bfd/coffswap.h gdb-7.3.1/bfd/coffswap.h
--- gdb-7.3.1.orig/bfd/coffswap.h	2009-09-05 07:56:22 +0000
+++ gdb-7.3.1/bfd/coffswap.h	2012-01-08 00:21:28 +0000
@@ -765,12 +765,17 @@ coff_swap_scnhdr_in (bfd * abfd, void *
 
   scnhdr_int->s_scnptr = GET_SCNHDR_SCNPTR (abfd, scnhdr_ext->s_scnptr);
   scnhdr_int->s_relptr = GET_SCNHDR_RELPTR (abfd, scnhdr_ext->s_relptr);
   scnhdr_int->s_lnnoptr = GET_SCNHDR_LNNOPTR (abfd, scnhdr_ext->s_lnnoptr);
   scnhdr_int->s_flags = GET_SCNHDR_FLAGS (abfd, scnhdr_ext->s_flags);
+#if defined (COFF_GO32_EXE) || defined(COFF_GO32)
+  scnhdr_int->s_nreloc = GET_SCNHDR_NRELOC_EXTENDED (abfd, scnhdr_ext);
+  scnhdr_int->s_nlnno = GET_SCNHDR_NLNNO_EXTENDED (abfd, scnhdr_ext);
+#else
   scnhdr_int->s_nreloc = GET_SCNHDR_NRELOC (abfd, scnhdr_ext->s_nreloc);
   scnhdr_int->s_nlnno = GET_SCNHDR_NLNNO (abfd, scnhdr_ext->s_nlnno);
+#endif
 #ifdef I960
   scnhdr_int->s_align = GET_SCNHDR_ALIGN (abfd, scnhdr_ext->s_align);
 #endif
 #ifdef COFF_ADJUST_SCNHDR_IN_POST
   COFF_ADJUST_SCNHDR_IN_POST (abfd, ext, in);
@@ -797,10 +802,13 @@ coff_swap_scnhdr_out (bfd * abfd, void *
   PUT_SCNHDR_LNNOPTR (abfd, scnhdr_int->s_lnnoptr, scnhdr_ext->s_lnnoptr);
   PUT_SCNHDR_FLAGS (abfd, scnhdr_int->s_flags, scnhdr_ext->s_flags);
 #if defined(M88)
   H_PUT_32 (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
   H_PUT_32 (abfd, scnhdr_int->s_nreloc, scnhdr_ext->s_nreloc);
+#elif defined (COFF_GO32_EXE) || defined(COFF_GO32)
+  PUT_SCNHDR_NLNNO_EXTENDED(abdf, scnhdr_int, scnhdr_ext);
+  PUT_SCNHDR_NRELOC_EXTENDED(abdf, scnhdr_int, scnhdr_ext);
 #else
   if (scnhdr_int->s_nlnno <= MAX_SCNHDR_NLNNO)
     PUT_SCNHDR_NLNNO (abfd, scnhdr_int->s_nlnno, scnhdr_ext->s_nlnno);
   else
     {
diff -aprNU5 gdb-7.3.1.orig/bfd/libcoff-in.h gdb-7.3.1/bfd/libcoff-in.h
--- gdb-7.3.1.orig/bfd/libcoff-in.h	2011-03-31 08:08:38 +0000
+++ gdb-7.3.1/bfd/libcoff-in.h	2012-01-08 00:21:28 +0000
@@ -25,10 +25,11 @@
 
 /* Object file tdata; access macros.  */
 
 #define coff_data(bfd)		      ((bfd)->tdata.coff_obj_data)
 #define obj_pe(bfd)                   (coff_data (bfd)->pe)
+#define obj_go32(bfd)                 (coff_data (bfd)->go32)
 #define obj_symbols(bfd)	      (coff_data (bfd)->symbols)
 #define	obj_sym_filepos(bfd)	      (coff_data (bfd)->sym_filepos)
 #define obj_relocbase(bfd)	      (coff_data (bfd)->relocbase)
 #define obj_raw_syments(bfd)	      (coff_data (bfd)->raw_syments)
 #define obj_raw_syment_count(bfd)     (coff_data (bfd)->raw_syment_count)
@@ -103,10 +104,12 @@ typedef struct coff_tdata
 
   /* Copy of some of the f_flags bits in the COFF filehdr structure,
      used by ARM code.  */
   flagword flags;
 
+  /* Is this a GO32 coff file?  */
+  int go32;
   /* coff-stgo32 EXE stub header after BFD tdata has been allocated.  Its data
      is kept in internal_filehdr.go32stub beforehand.  */
   char *go32stub;
 } coff_data_type;
 
diff -aprNU5 gdb-7.3.1.orig/config.sub gdb-7.3.1/config.sub
--- gdb-7.3.1.orig/config.sub	2011-03-24 11:13:32 +0000
+++ gdb-7.3.1/config.sub	2012-01-08 00:21:28 +0000
@@ -593,11 +593,19 @@ case $basic_machine in
 	dicos)
 		basic_machine=i686-pc
 		os=-dicos
 		;;
 	djgpp)
-		basic_machine=i586-pc
+		UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+		case $UNAME_MACHINE in
+			*386*) basic_machine=i386-pc;;
+			*486*) basic_machine=i486-pc;;
+			*586*) basic_machine=i586-pc;;
+			*686*) basic_machine=i686-pc;;
+			*786*) basic_machine=i786-pc;;
+			*)     basic_machine=i586-pc;;
+		esac
 		os=-msdosdjgpp
 		;;
 	dpx20 | dpx20-*)
 		basic_machine=rs6000-bull
 		os=-bosx
diff -aprNU5 gdb-7.3.1.orig/djgpp/bfdsymify/ChangeLog gdb-7.3.1/djgpp/bfdsymify/ChangeLog
--- gdb-7.3.1.orig/djgpp/bfdsymify/ChangeLog	1970-01-01 00:00:00 +0000
+++ gdb-7.3.1/djgpp/bfdsymify/ChangeLog	2012-01-08 00:21:28 +0000
@@ -0,0 +1,5 @@
+2006-02-18 Andris Pavenis <andris.pavenis@saunalahti.fi>
+	Modified BFDSYMIFY to work with BFD from GDB-6.4. Had to use
+	bfd_get_section_size() instead of bfd_get_section_size_befor_reloc().
+	I'm not sure that this is correct, but it seems to at least work for 
+	DJGPP.
diff -aprNU5 gdb-7.3.1.orig/djgpp/bfdsymify/Makefile gdb-7.3.1/djgpp/bfdsymify/Makefile
--- gdb-7.3.1.orig/djgpp/bfdsymify/Makefile	1970-01-01 00:00:00 +0000
+++ gdb-7.3.1/djgpp/bfdsymify/Makefile	2012-01-08 00:21:28 +0000
@@ -0,0 +1,11 @@
+CFLAGS = -Wall -O2
+srcdir = ..
+CPPFLAGS = -I. -I$(srcdir)/../include -I$(srcdir)/bfd -I$(srcdir)/libiberty -I$(srcdir)/intl
+CC = gcc
+
+# if compiled with NLS support enable uncomment this line.
+# bfdsymify: bfdsymify.o ../bfd/.libs/libbfd.a ../libiberty/libiberty.a ../intl/libintl.a -liconv -lz
+
+# if compiled with NLS support disable uncomment this line.
+bfdsymify: bfdsymify.o ../bfd/.libs/libbfd.a ../libiberty/libiberty.a -lz
+	$(CC) $(CFLAGS) -o $@ $+
diff -aprNU5 gdb-7.3.1.orig/djgpp/bfdsymify/bfdsymify.c gdb-7.3.1/djgpp/bfdsymify/bfdsymify.c
--- gdb-7.3.1.orig/djgpp/bfdsymify/bfdsymify.c	1970-01-01 00:00:00 +0000
+++ gdb-7.3.1/djgpp/bfdsymify/bfdsymify.c	2012-01-08 02:43:02 +0000
@@ -0,0 +1,836 @@
+/* Copyright (C) 2012 DJ Delorie, see COPYING.DJ for details */
+/* Copyright (C) 1999 DJ Delorie, see COPYING.DJ for details */
+/* Copyright (C) 1996 DJ Delorie, see COPYING.DJ for details */
+/* Copyright (C) 1995 DJ Delorie, see COPYING.DJ for details */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <pc.h>
+
+#include "bfd.h"
+#include "bfdver.h"
+#include "getopt.h"
+#include "libiberty.h"
+#include "demangle.h"
+
+#define SC(r,c) (*(char *)(sc + (r) * screen_cols + (c)))
+#define SW(r,c) (*(sc + (r) * screen_cols + (c)))
+
+#undef basename
+
+static asymbol **syms;		/* Symbol table.  */
+static asymbol **sorted_syms;	/* Sorted symbol table.  */
+static long symcount;
+static long sorted_symcount;
+
+/* Dummy functions, for now.  */
+
+static void
+bfd_fatal(const char *msg)
+{
+  fprintf(stderr, "BFD fatal: %s\n", msg);
+  exit(1);
+}
+
+static void
+bfd_nonfatal(const char *msg)
+{
+  fprintf(stderr, "BFD warning: %s\n", msg);
+}
+
+static void
+list_matching_formats(char **formats)
+{
+}
+
+static void
+set_default_bfd_target(void)
+{
+  bfd_set_default_target("coff-go32-exe");
+}
+/* Read in the symbol table.  */
+
+static void
+slurp_symtab(bfd *bfdp)
+{
+  long storage;
+
+  if ((bfd_get_file_flags(bfdp) & HAS_SYMS) == 0)
+    return;
+
+  storage = bfd_get_symtab_upper_bound(bfdp);
+  if (storage < 0)
+    bfd_fatal(bfd_get_filename(bfdp));
+
+  syms = (asymbol **)xmalloc(storage);
+
+  symcount = bfd_canonicalize_symtab(bfdp, syms);
+  if (symcount < 0)
+    bfd_fatal(bfd_get_filename(bfdp));
+}
+
+/* Filter out (in place) symbols that are useless for disassembly.
+   COUNT is the number of elements in SYMBOLS.
+   Return the number of useful symbols. */
+
+static long
+remove_useless_symbols (symbols, count)
+     asymbol **symbols;
+     long count;
+{
+  register asymbol **in_ptr = symbols, **out_ptr = symbols;
+
+  while (--count >= 0)
+  {
+    asymbol *sym = *in_ptr++;
+
+    if (sym->name == NULL || sym->name[0] == '\0')
+      continue;
+    /* The funky symbols .bb, .eb, .ef, .bf get in the way.  */
+    if (sym->name[0] == '.'
+        && (sym->name[1] == 'b' || sym->name[1] == 'e')
+        && (sym->name[2] == 'b' || sym->name[2] == 'f')
+        && sym->name[3] == '\0')
+      continue;
+    if (strncmp(sym->name, ".debug_", 7) == 0)
+      continue;
+    if (sym->flags & (BSF_DEBUGGING))
+      continue;
+    if (bfd_is_und_section(sym->section)
+        || bfd_is_com_section(sym->section))
+      continue;
+
+    *out_ptr++ = sym;
+  }
+  return out_ptr - symbols;
+}
+
+/* Sort symbols into value order.  */
+
+static int
+compare_symbols(ap, bp)
+     const PTR ap;
+     const PTR bp;
+{
+  const asymbol *a = *(const asymbol **)ap;
+  const asymbol *b = *(const asymbol **)bp;
+  const char *an, *bn;
+  size_t anl, bnl;
+  bool af, bf;
+  flagword aflags, bflags;
+
+  if (bfd_asymbol_value(a) > bfd_asymbol_value(b))
+    return 1;
+  else if (bfd_asymbol_value(a) < bfd_asymbol_value(b))
+    return -1;
+
+  if (a->section > b->section)
+    return 1;
+  else if (a->section < b->section)
+    return -1;
+
+  an = bfd_asymbol_name(a);
+  bn = bfd_asymbol_name(b);
+  anl = strlen(an);
+  bnl = strlen(bn);
+
+  /* The symbols gnu_compiled and gcc2_compiled convey no real
+     information, so put them after other symbols with the same value.  */
+
+  af = (strstr (an, "gnu_compiled") != NULL
+	|| strstr (an, "gcc2_compiled") != NULL);
+  bf = (strstr (bn, "gnu_compiled") != NULL
+	|| strstr (bn, "gcc2_compiled") != NULL);
+
+  if (af && ! bf)
+    return 1;
+  if (! af && bf)
+    return -1;
+
+  /* We use a heuristic for the file name, to try to sort it after
+     more useful symbols.  It may not work on non Unix systems, but it
+     doesn't really matter; the only difference is precisely which
+     symbol names get printed.  */
+
+#define file_symbol(s, sn, snl)			\
+  (((s)->flags & BSF_FILE) != 0			\
+   || ((sn)[(snl) - 2] == '.'			\
+       && ((sn)[(snl) - 1] == 'o'		\
+	   || (sn)[(snl) - 1] == 'a')))
+
+  af = file_symbol(a, an, anl);
+  bf = file_symbol(b, bn, bnl);
+
+  if (af && ! bf)
+    return 1;
+  if (! af && bf)
+    return -1;
+
+  /* Try to sort global symbols before local symbols before function
+     symbols before debugging symbols.  */
+
+  aflags = a->flags;
+  bflags = b->flags;
+
+  if ((aflags & BSF_DEBUGGING) != (bflags & BSF_DEBUGGING))
+  {
+    if ((aflags & BSF_DEBUGGING) != 0)
+      return 1;
+    else
+      return -1;
+  }
+  if ((aflags & BSF_FUNCTION) != (bflags & BSF_FUNCTION))
+  {
+    if ((aflags & BSF_FUNCTION) != 0)
+      return -1;
+    else
+     return 1;
+  }
+  if ((aflags & BSF_LOCAL) != (bflags & BSF_LOCAL))
+  {
+    if ((aflags & BSF_LOCAL) != 0)
+      return 1;
+    else
+     return -1;
+  }
+  if ((aflags & BSF_GLOBAL) != (bflags & BSF_GLOBAL))
+  {
+    if ((aflags & BSF_GLOBAL) != 0)
+      return -1;
+    else
+      return 1;
+  }
+
+  /* Symbols that start with '.' might be section names, so sort them
+     after symbols that don't start with '.'.  */
+  if (an[0] == '.' && bn[0] != '.')
+    return 1;
+  if (an[0] != '.' && bn[0] == '.')
+    return -1;
+
+  /* Finally, if we can't distinguish them in any other way, try to
+     get consistent results by sorting the symbols by name.  */
+  return strcmp(an, bn);
+}
+
+static bfd *
+init_bfd_syms_or_die(const char *prog, const char *tgt)
+{
+  char **matching;
+  bfd  *bfdp;
+
+  bfdp = bfd_openr(prog, tgt);
+  if (bfdp == NULL)
+    bfd_fatal(prog);
+
+  if (bfd_check_format(bfdp, bfd_archive))
+    fprintf (stderr, "%s: can not get addresses from archive\n", prog);
+
+  if (!bfd_check_format_matches(bfdp, bfd_object, &matching))
+  {
+    bfd_nonfatal(bfd_get_filename(bfdp));
+    if (bfd_get_error() == bfd_error_file_ambiguously_recognized)
+    {
+      list_matching_formats(matching);
+      free(matching);
+    }
+    exit(1);
+  }
+
+  slurp_symtab(bfdp);
+
+  /* We make a copy of syms to sort.  We don't want to sort syms
+     because that will screw up the relocs.  */
+  sorted_syms = (asymbol **) xmalloc(symcount * sizeof (asymbol *));
+  memcpy(sorted_syms, syms, symcount * sizeof (asymbol *));
+
+  sorted_symcount = remove_useless_symbols(sorted_syms, symcount);
+
+  /* Sort the symbols into section and symbol order */
+  qsort(sorted_syms, sorted_symcount, sizeof (asymbol *), compare_symbols);
+
+  return bfdp;
+}
+
+/* Locate a symbol given a bfd, a section, and a VMA.  */
+
+static asymbol *
+find_symbol_for_address(abfd, sec, vma)
+     bfd *abfd;
+     asection *sec;
+     bfd_vma vma;
+{
+  /* @@ Would it speed things up to cache the last two symbols returned,
+     and maybe their address ranges?  For many processors, only one memory
+     operand can be present at a time, so the 2-entry cache wouldn't be
+     constantly churned by code doing heavy memory accesses.  */
+
+  /* Indices in `sorted_syms'.  */
+  long min = 0;
+  long max = sorted_symcount;
+  long thisplace;
+
+  if (sorted_symcount < 1)
+    return NULL;
+
+  /* Perform a binary search looking for the closest symbol to the
+     required value.  We are searching the range (min, max].  */
+  while (min + 1 < max)
+  {
+    asymbol *sym;
+
+    thisplace = (max + min) / 2;
+    sym = sorted_syms[thisplace];
+
+    if (bfd_asymbol_value (sym) > vma)
+      max = thisplace;
+    else if (bfd_asymbol_value (sym) < vma)
+      min = thisplace;
+    else
+    {
+      min = thisplace;
+      break;
+    }
+  }
+
+  /* The symbol we want is now in min, the low end of the range we
+     were searching.  If there are several symbols with the same
+     value, we want the first one.  */
+  thisplace = min;
+  while (thisplace > 0
+         && (bfd_asymbol_value (sorted_syms[thisplace])
+             == bfd_asymbol_value (sorted_syms[thisplace - 1])))
+    --thisplace;
+
+  /* If the file is relocateable, and the symbol could be from this
+     section, prefer a symbol from this section over symbols from
+     others, even if the other symbol's value might be closer.
+
+     Note that this may be wrong for some symbol references if the
+     sections have overlapping memory ranges, but in that case there's
+     no way to tell what's desired without looking at the relocation
+     table.  */
+
+  if (sorted_syms[thisplace]->section != sec
+      && ((abfd->flags & HAS_RELOC) != 0
+          && vma >= bfd_get_section_vma (abfd, sec)
+          && vma < (bfd_get_section_vma (abfd, sec)
+                    + bfd_section_size (abfd, sec))))
+  {
+    long i;
+
+    for (i = thisplace + 1; i < sorted_symcount; i++)
+    {
+      if (bfd_asymbol_value (sorted_syms[i])
+          != bfd_asymbol_value (sorted_syms[thisplace]))
+        break;
+    }
+    for (--i; i >= 0; i--)
+    {
+      if (sorted_syms[i]->section == sec
+          && (i == 0
+              || sorted_syms[i - 1]->section != sec
+              || (bfd_asymbol_value (sorted_syms[i])
+                  != bfd_asymbol_value (sorted_syms[i - 1]))))
+      {
+        thisplace = i;
+        break;
+      }
+    }
+
+    if (sorted_syms[thisplace]->section != sec)
+    {
+      /* We didn't find a good symbol with a smaller value.
+         Look for one with a larger value.  */
+      for (i = thisplace + 1; i < sorted_symcount; i++)
+      {
+        if (sorted_syms[i]->section == sec)
+        {
+          thisplace = i;
+          break;
+        }
+      }
+    }
+
+    if (sorted_syms[thisplace]->section != sec
+        && ((abfd->flags & HAS_RELOC) != 0
+             && vma >= bfd_get_section_vma (abfd, sec)
+             && vma < (bfd_get_section_vma (abfd, sec)
+                       + bfd_section_size (abfd, sec))))
+    {
+      /* There is no suitable symbol.  */
+      return NULL;
+    }
+  }
+
+  return sorted_syms[thisplace];
+}
+
+/* These global variables are used to pass information between
+   translate_address and find_address_in_section.  */
+
+static bfd_vma pc;
+static const char *filename;
+static const char *functionname;
+static unsigned int linenum;
+static unsigned long offset;
+static int found;
+
+/* Look for an address in a section.  This is called via
+   bfd_map_over_sections.  */
+
+static void
+find_address_in_section (bfd *bfdp, asection *section, void *data)
+{
+  bfd_vma vma;
+  bfd_size_type size;
+
+  if (found)
+    return;
+
+  if ((bfd_get_section_flags(bfdp, section) & SEC_ALLOC) == 0)
+    return;
+
+  vma = bfd_get_section_vma(bfdp, section);
+  if (pc < vma)
+    return;
+
+  size = bfd_get_section_size (section);
+  if (pc >= vma + size)
+    return;
+
+  found = bfd_find_nearest_line(bfdp, section, syms, pc - vma,
+				&filename, &functionname, &linenum);
+}
+
+static void
+find_symbol_in_section(bfd *bfdp, asection *section, void *data)
+{
+  asymbol *sym0, *sym;
+  bfd_vma vma;
+
+  if (found)
+    return;
+
+  vma = bfd_get_section_vma(bfdp, section);
+  if (pc < vma)
+    return;
+
+  sym = sym0 = find_symbol_for_address(bfdp, section, pc);
+  if (sym)
+    {
+      const char *f = bfd_asymbol_name(sym);
+      int i = 0;
+
+      if (!functionname || *functionname == '\0')
+	functionname = f;
+
+      /* find_symbol_for_address has a nasty habit of finding local
+	 labels and other irrelevant symbols that are closer to PC
+	 than the enclosing function.  This loop searches backwards
+	 until it finds a symbol with the same name as FUNCTIONNAME.  */
+      while (i < 0x1000 && strcmp(f, functionname) != 0)
+	{
+	  sym = find_symbol_for_address(bfdp, section,
+					bfd_asymbol_value(sym) - 1);
+	  if (!sym)
+	    break;
+	  f = bfd_asymbol_name(sym);
+	  i++;		/* don't look too far... */
+	}
+      if (i >= 0x1000)	/* not found--fall back on the original guess */
+	sym = sym0;
+    }
+  if (sym)
+    {
+      found = 1;
+      functionname = bfd_asymbol_name(sym);
+      offset = pc - bfd_asymbol_value(sym);
+    }
+}
+
+static void
+translate_address(unsigned v, bfd *bfdp,
+		  char **func, int *lineno, char **file, unsigned long *offs)
+{
+  char *demangled_name;
+
+  pc = v;
+  found = 0;
+  bfd_map_over_sections(bfdp, find_address_in_section, (void *)NULL);
+  if (!found)
+  {
+    *func = NULL;
+    *file = NULL;
+    *lineno = -1;
+    *offs = 0;
+    functionname = NULL;
+  }
+  else
+    *file = (char *)filename;
+  if (!functionname || *functionname == '\0')
+    {
+      *lineno = -1;
+      *func = NULL;
+    }
+  else
+    *func = (char *)functionname;
+  found = 0;
+  bfd_map_over_sections(bfdp, find_symbol_in_section, (void *)NULL);
+  if (found)
+    {
+      /* The convoluted comparison with `main' is so that we filter
+	 out false attributions of EIPs in library functions to the
+	 last line of the main function.  */
+      if (*func
+	  && (strcmp (*func, "main") == 0
+	      || strcmp (*func, "_main") == 0)
+	  && strcmp (functionname, "main") != 0
+	  && strcmp (functionname, "_main") != 0)
+	{
+	  *file = NULL;
+	  *lineno = -1;
+	}
+      *func = (char *)functionname;
+    }
+  if (found && *func && **func != '\0')
+    {
+      if (**func == bfd_get_symbol_leading_char(bfdp))
+	++*func;
+      demangled_name = cplus_demangle(*func, DMGL_ANSI | DMGL_PARAMS);
+      if (demangled_name)
+	*func = demangled_name;
+      *lineno = linenum;
+      *offs = offset;
+    }
+}
+
+int main(int argc, char **argv)
+{
+  int r, c;
+  short *sc;
+  char *buf = NULL;
+  size_t bufsize = 0;
+  int i, lineno;
+  unsigned v;
+  unsigned long d;
+  char *func, *file;
+  FILE *ofile=0;
+  FILE *ifile=0;
+  char *progname = NULL;
+  char *bfdsymify;
+  bfd  *abfd = NULL;
+  char *target = NULL;
+  int   screen_rows, screen_cols, cursor_row, cursor_col;
+
+  bfdsymify = argv[0];
+
+  if (argc < 2)
+  {
+    fprintf(stderr,
+	    "BFDSymify Version 1.2, 2002-02-24 (BFD version %s)\n",
+            BFD_VERSION_STRING);
+    fprintf(stderr,
+	    "Add source file information to a DJGPP program's call-frame traceback\n\n");
+    fprintf(stderr, "Usage: bfdsymify [-o <outfile>] [-i <corefile>] <program>\n");
+    return 1;
+  }
+  while (argv[1][0] == '-')
+  {
+    if ((strcmp(argv[1], "-o") == 0) && (argc > 3))
+    {
+      ofile = fopen(argv[2], "w");
+      if (ofile == 0)
+        fprintf(stderr, "Error: unable to open file %s\n", argv[2]);
+      argc -= 2;
+      argv += 2;
+    }
+    else if ((strcmp(argv[1], "-i") == 0) && (argc > 3))
+    {
+      ifile = fopen(argv[2], "r");
+      if (ifile == 0)
+        fprintf(stderr, "Error: unable to open file %s\n", argv[2]);
+      argc -= 2;
+      argv += 2;
+    }
+    else
+    {
+      fprintf(stderr, "Invalid option %s - type `%s' for help\n",
+	      argv[1], bfdsymify);
+      exit(1);
+    }
+  }
+
+  progname = argv[1];
+  bfd_init();
+  set_default_bfd_target();
+
+  if (ifile)
+  {
+    char line[1000];
+    if (ofile == 0)
+      ofile = stdout;
+    while (fgets(line, 1000, ifile))
+    {
+      if (strncmp(line + 25, " program=", 9) == 0)
+      {
+	fputs(line, ofile);
+	if (progname)
+	{
+	  char *arg_base = basename(progname), *prog_base = basename(line + 9);
+	  if (strcasecmp(prog_base, arg_base)
+	      && strncasecmp(prog_base, arg_base, strlen(prog_base) - 4))
+	    fprintf(stderr,
+		    "!!! Program name in corefile doesn't match `%s'\n",
+		    progname);
+	}
+	else
+	  progname = strdup(line + 9);
+      }
+      else if (strncmp(line, "  0x", 4) == 0)
+      {
+	if (progname == NULL)
+	{
+	  progname = "a.exe";
+	  if (access(progname, R_OK))
+	  {
+	    progname = "a.out";
+	    if (access(progname, R_OK))
+	    {
+	      fprintf(stderr, "Error: no usable program name given.\n");
+	      exit (1);
+	    }
+	  }
+	}
+	if (abfd == NULL)
+	  abfd = init_bfd_syms_or_die(progname, target);
+        sscanf(line+4, "%x", &v);
+
+	translate_address(v, abfd, &func, &lineno, &file, &d);
+        fprintf(ofile, "  0x%08x", v);
+        if (func)
+        {
+          fprintf(ofile, " %s", func);
+          if (d)
+            fprintf(ofile, "%+ld", d);
+        }
+        if (file)
+        {
+          if (func)
+            fprintf(ofile, ", ");
+	  fprintf(ofile, "file %s", file);
+	  if (lineno > 0)
+	    fprintf (ofile, ", line %d", lineno);
+        }
+        fputc('\n', ofile);
+      }
+      else
+        fputs(line, ofile);
+    }
+
+    if (syms != NULL)
+    {
+      free(syms);
+      syms = NULL;
+      free(sorted_syms);
+    }
+
+    if (abfd)
+      bfd_close(abfd);
+    return 0;
+  }
+
+  screen_rows = ScreenRows();
+  screen_cols =  ScreenCols();
+  sc = (short *)malloc(screen_rows * screen_cols * 2);
+
+  ScreenGetCursor(&cursor_row, &cursor_col);
+
+  ScreenRetrieve(sc);	/* FIXME: handle graphics modes! */
+
+  bufsize = screen_cols + 10;
+  buf = xmalloc (bufsize);
+
+  for (r = 0; r < screen_rows; r++)
+  {
+    if (SC(r,25) == ' '
+	&& SC(r,26) == 'p' && SC(r,27) == 'r' && SC(r,28) == 'o'
+	&& SC(r,29) == 'g' && SC(r,30) == 'r' && SC(r,31) == 'a'
+	&& SC(r,32) == 'm' && SC(r,33) == '=')
+    {
+      char prog[FILENAME_MAX];
+
+      /* The test for blank relies on the fact that DJGPP programs
+	 always get short 8+3 aliases as their DOS argv[0], and those
+	 cannot have embedded blanks.  */
+      for (i = 26; SC(r,i) != ' ' && SC(r,i) != '\0'; i++)
+	prog[i - 26] = SC(r, i);
+      prog[i - 26] = 0;
+      /* If the name is extremely long, it may overflow into the next
+	 screen line, and we err by one row at this point.  (We cannot
+	 possibly be more than one row off, since short path names are
+	 never longer than 80 characters.)  */
+      if (i >= screen_cols)
+      {
+	r += 1;
+	i -= screen_cols;
+      }
+      if (progname)
+      {
+	char *arg_base = basename(progname), *prog_base = basename(prog);
+
+	if (strcasecmp(prog_base, arg_base)
+	    && (strncasecmp(prog_base, arg_base, strlen(prog_base) - 4)
+		|| arg_base[strlen(prog_base) - 4])) /* FIXME: LFN and 8+3 */
+	  {
+	    sprintf(buf,
+		    "!!! Program name on screen doesn't match `%s'",
+		    progname);
+
+	    for (i = 0; buf[i]; i++)
+	      SW(cursor_row, i) = 0x0700 + buf[i];
+	  }
+      }
+      else
+	progname = strdup(prog);
+    }
+    else if (SC(r, 0) == ' ' && SC(r, 1) == ' '
+	     && SC(r, 2) == '0' && SC(r, 3) == 'x')
+    {
+      int l_left = bufsize - 1, l_func = 0, l_off = 0, l_file = 0, l_line = 0;
+      if (progname == NULL)
+      {
+	progname = "a.exe";
+	if (access(progname, R_OK))
+	{
+	  progname = "a.out";
+	  if (access(progname, R_OK))
+	  {
+	    ScreenSetCursor(cursor_row, cursor_col);
+	    fprintf(stderr, "Error: no usable program name given.\n");
+	    exit (1);
+	  }
+	}
+      }
+      if (abfd == NULL)
+	abfd = init_bfd_syms_or_die(progname, target);
+      buf[8] = 0;
+      for (i = 0; i < 8; i++)
+        buf[i] = SC(r, i + 4);
+      sscanf(buf, "%x", &v);
+      translate_address(v, abfd, &func, &lineno, &file, &d);
+      if (ofile)
+	fprintf (ofile, "  0x%08x", v);
+      buf[0] = 0;
+      if (func)
+      {
+	l_func = strlen (func);
+	if (l_func > l_left - 10)
+	{
+	  bufsize += l_func + 10;
+	  l_left += l_func + 10;
+	  buf = xrealloc (buf, bufsize);
+	}
+	strcat(buf, func);
+	l_left -= l_func;
+	if (d)
+	{
+	  l_left -= sprintf(buf + l_func, "%+ld", d);
+	  l_off = strlen(buf);
+	}
+	else
+	  l_off = l_func;
+      }
+      if (file)
+      {
+	l_file = strlen(file);
+	if (l_left < l_file + 25)
+	{
+	  bufsize += l_file + 25;
+	  l_left += l_file + 25;
+	  buf = xrealloc (buf, bufsize);
+	}
+        if (buf[0])
+	{
+          strcat(buf, ", ");
+	  l_left -= 2;
+	}
+        sprintf(buf+strlen(buf), "file %s", file);
+	l_file = strlen(buf);
+	if (lineno > 0)
+	  sprintf(buf+strlen(buf), ", line %d", lineno);
+      }
+      else
+	l_file = l_off;
+      l_line = strlen(buf);
+      if (buf[0])
+      {
+	int j;
+	int max_func =
+	  l_line > screen_cols - 13 && l_off > screen_cols / 2 - 6
+	  ? screen_cols / 2 - 8 - (l_off - l_func)
+	  : l_off;
+	int in_func = 1, in_file = 0;
+
+	/* 0xdeadbeef _FooBar_Func..+666, file FooBarF..e.Ext, line 1234  */
+	/*            ^             ^   ^                    ^          ^ */
+	/*            0        l_func l_off             l_file     l_line */
+	for (i = 0, j = 0; buf[j]; i++, j++)
+	{
+	  if (13 + i >= screen_cols)
+	    break;
+	  else if (in_func && i >= max_func && j < l_off)
+	  {
+	    SW(r, 13 + i) = 0x0700 + '.'; i++;
+	    SW(r, 13 + i) = 0x0700 + '.'; i++;
+	    j = l_func;		/* truncate function name, jump to offset */
+	    in_func = 0;
+	    in_file = 1;
+	  }
+	  else if (in_file
+		   && 13 + i >= screen_cols - 8 - (l_line - l_file)
+		   && j < l_file - 6)
+	  {
+	    SW(r, 13 + i) = 0x0700 + '.'; i++;
+	    SW(r, 13 + i) = 0x0700 + '.'; i++;
+	    j = l_file - 6;	/* jump to last portion of file name */
+	    in_file = 0;
+	  }
+	  SW(r, 13 + i) = 0x0f00 + buf[j];
+	}
+	if (ofile)
+	  fprintf (ofile, " %s\n", buf);
+      }
+    }
+  }
+
+  if (ofile)
+  {
+    for (r = 0; r < screen_rows; r++)
+    {
+      c = 0;
+      for (i = 0; i < screen_cols; i++)
+        if (SC(r, i) != ' ')
+          c = i;
+      for (i = 0; i <= c; i++)
+        fputc(SC(r, i), ofile);
+      fputc('\n', ofile);
+    }
+    fclose(ofile);
+  }
+  else
+    ScreenUpdate(sc);	/* FIXME: graphics modes */
+
+  if (syms != NULL)
+  {
+    free(syms);
+    syms = NULL;
+    free(sorted_syms);
+  }
+
+  if (abfd)
+    bfd_close(abfd);
+  return 0;
+}
diff -aprNU5 gdb-7.3.1.orig/djgpp/bfdsymify/readme gdb-7.3.1/djgpp/bfdsymify/readme
--- gdb-7.3.1.orig/djgpp/bfdsymify/readme	1970-01-01 00:00:00 +0000
+++ gdb-7.3.1/djgpp/bfdsymify/readme	2012-01-08 00:21:28 +0000
@@ -0,0 +1,23 @@
+Once upon a time, a long, LONG time ago, DJ asked for a version of
+SYMIFY that would be based on BFD functions, rather than on our
+private syms.c from libdbg.a.  The advantage of this would be that
+such a program would automatically support every format of debugging
+info that BFD is configured to support, not only the COFF debug info
+supported by libdbg.a.
+
+Well, it took more than a year, but I finally got to making it happen.
+I called the program BFDSYMIFY, but that's a temporary name (it also
+exceeds DOS 8+3 limits, which isn't very nice), so if you have a
+better name, I am open to suggestions.  My intent was to eventually ask
+the Binutils maintainer to include this program as part of Binutils,
+but it looks like it won't happen any time soon...
+
+In the meantime, I'm making it available as part of GDB distro.
+
+Please tell me how well does bfdsymify work (or doesn't work) for you.
+
+
+Enjoy,
+                                  Eli Zaretskii  <eliz@is.elta.co.il>
+
+
diff -aprNU5 gdb-7.3.1.orig/djgpp/build.sh gdb-7.3.1/djgpp/build.sh
--- gdb-7.3.1.orig/djgpp/build.sh	1970-01-01 00:00:00 +0000
+++ gdb-7.3.1/djgpp/build.sh	2012-01-08 00:21:28 +0000
@@ -0,0 +1,130 @@
+#  This script only works in the ./djgpp directory.
+
+export HOME=.
+export PATH_SEPARATOR=:
+export PATH_EXPAND=y
+export TEST_FINDS_EXE=y
+export LD=ld
+export NM=nm
+export LN_S="cp -p"
+export ac_cv_prog_LN_S="cp -p"
+export ac_cv_func_fork=no
+export ac_cv_func_mkfifo=no
+export ac_cv_func_mknod=no
+export ac_cv_func_mmap=no
+export ac_cv_func_pipe=no
+export ac_cv_func_vfork=no
+
+
+
+#
+#  1: Adjust the configure scripts.
+#
+
+cat > script.sed << EOF
+# For some reason the function does not work with bash 2.05b.
+/^func_lalib_p/,/^}$/ {
+  /test/ i\\
+    case \$1 in\\
+    *.la | *.lo)
+  /GREP/ {
+    s/$/;;/
+    a\\
+    *) false;;\\
+    esac
+  }
+}
+
+# The CR test for awk does not work for DJGPP.
+/^ac_cs_awk_cr=/,/^$/ {
+  /^fi$/ a\\
+ac_cs_awk_cr=\$ac_cr
+}
+
+# AWK program above erroneously prepends '/' to C:/dos/paths
+/# AWK program above erroneously prepends/,/esac/ {
+  s/mingw/*djgpp* | mingw/
+}
+
+# Force the test for 'ln -s' to report 'cp -pf'.
+/as_ln_s='ln -s'/ s/ln -s/cp -pf/
+
+# We have an emulation of nl_langinfo in go32-nat.c that supports CODESET.
+/^for ac_var in \\\$ac_precious_vars; do/i\\
+am_cv_langinfo_codeset=yes\\
+bash_cv_langinfo_codeset=yes\\
+ac_cv_header_nl_types_h=yes
+
+# Add pdcurses to the search list.
+/for ac_lib in.*ncurses cursesX curses/ s/ncurses/pdcurses &/
+EOF
+
+
+for file in ../ltmain.sh ../configure ../bfd/configure ../etc/configure ../gdb/configure ../opcodes/configure ../readline/configure; do
+  if test ! -f ${file}.orig; then
+    cp -vf ${file} ${file}.orig
+    touch ${file}.orig -r ${file}
+  fi
+  sed -f ./script.sed ${file}.orig > ./file.out
+  update ./file.out ${file}
+  touch ${file} -r ${file}.orig
+done
+rm -vf ./file.out ./script.sed
+
+
+
+#
+#  3: Adjust the Makefile.in and other files.
+#
+
+cat > script.sed << EOF
+# Fix for ./gdb/data-directory/Makefile.in
+/^stamp-syscalls:/ s/\\\$(SYSCALLS_FILES)/#&/
+
+# Force the regenaration of libcoff.h
+# to define obj_go32
+/^\\\$(BFD_H):/ s/:/: stmp-lcoff-h/
+EOF
+
+
+for file in ./../gdb/data-directory/Makefile.in ./../bfd/Makefile.in; do
+  if test ! -f ${file}.orig; then
+    cp -vf ${file} ${file}.orig
+    touch ${file}.orig -r ${file}
+  fi
+  sed -f ./script.sed ${file}.orig > ./file.out
+  update ./file.out ${file}
+  touch ${file} -r ${file}.orig
+done
+rm -vf ./file.out ./script.sed
+
+
+#
+#  4: Configure and build the libs and programs.
+#
+
+echo
+echo Configuring the progs and libs.
+echo See log.txt file for output.
+echo Configuring the progs and libs for DJGPP. > log.txt
+echo >>log.txt
+
+# configuring the TUI support version.
+redir -eo  ../configure  --disable-dependency-tracking --disable-nls --with-mpc --with-mpfr --with-gmp --with-curses --enable-tui \
+                         --enable-build-warnings=-Wimplicit,-Wcomment,-Wformat,-Wparentheses,-Wpointer-arith >> log.txt
+
+# configuring without TUI support.
+# redir -eo  ../configure  --disable-dependency-tracking --disable-nls --with-mpc --with-mpfr --with-gmp --without-curses --disable-tui \
+#                          --enable-build-warnings=-Wimplicit,-Wcomment,-Wformat,-Wparentheses,-Wpointer-arith >> log.txt
+
+echo >>log.txt
+echo #######################################################>>log.txt
+echo >>log.txt
+
+
+echo
+echo Building the progs and libs.
+echo See log.txt file for output.
+echo Building the progs and libs for DJGPP. >> log.txt
+echo >>log.txt
+redir -eo  make >> log.txt
diff -aprNU5 gdb-7.3.1.orig/libiberty/make-relative-prefix.c gdb-7.3.1/libiberty/make-relative-prefix.c
--- gdb-7.3.1.orig/libiberty/make-relative-prefix.c	2011-02-03 07:23:58 +0000
+++ gdb-7.3.1/libiberty/make-relative-prefix.c	2012-01-08 00:21:28 +0000
@@ -77,10 +77,11 @@ relative prefix can be found, return @co
 #if defined (_WIN32) || defined (__MSDOS__) \
     || defined (__DJGPP__) || defined (__OS2__)
 #  define HAVE_DOS_BASED_FILE_SYSTEM
 #  define HAVE_HOST_EXECUTABLE_SUFFIX
 #  define HOST_EXECUTABLE_SUFFIX ".exe"
+#  define FILENAME_COMPARE strcasecmp
 #  ifndef DIR_SEPARATOR_2 
 #    define DIR_SEPARATOR_2 '\\'
 #  endif
 #  define PATH_SEPARATOR ';'
 #else
@@ -92,10 +93,13 @@ relative prefix can be found, return @co
 #else
 #  define IS_DIR_SEPARATOR(ch) \
 	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 #endif
 
+#ifndef FILENAME_COMPARE
+#  define FILENAME_COMPARE strcmp
+#endif
 #define DIR_UP ".."
 
 static char *save_string (const char *, int);
 static char **split_directories	(const char *, int *);
 static void free_split_directories (char **);
@@ -318,11 +322,11 @@ make_relative_prefix_1 (const char *prog
      we can do.  */
   if (prog_num == bin_num)
     {
       for (i = 0; i < bin_num; i++)
 	{
-	  if (strcmp (prog_dirs[i], bin_dirs[i]) != 0)
+	  if (FILENAME_COMPARE (prog_dirs[i], bin_dirs[i]) != 0)
 	    break;
 	}
 
       if (prog_num <= 0 || i == bin_num)
 	goto bailout;
@@ -334,11 +338,11 @@ make_relative_prefix_1 (const char *prog
 
   /* Find how many directories are in common between bin_prefix & prefix.  */
   n = (prefix_num < bin_num) ? prefix_num : bin_num;
   for (common = 0; common < n; common++)
     {
-      if (strcmp (bin_dirs[common], prefix_dirs[common]) != 0)
+      if (FILENAME_COMPARE (bin_dirs[common], prefix_dirs[common]) != 0)
 	break;
     }
 
   /* If there are no common directories, there can be no relative prefix.  */
   if (common == 0)
diff -aprNU5 gdb-7.3.1.orig/libiberty/make-temp-file.c gdb-7.3.1/libiberty/make-temp-file.c
--- gdb-7.3.1.orig/libiberty/make-temp-file.c	2011-01-03 21:05:58 +0000
+++ gdb-7.3.1/libiberty/make-temp-file.c	2012-01-08 00:21:28 +0000
@@ -53,16 +53,31 @@ extern int mkstemps (char *, int);
 /* '/' works just fine on MS-DOS based systems.  */
 #ifndef DIR_SEPARATOR
 #define DIR_SEPARATOR '/'
 #endif
 
+#if defined (_WIN32) || defined (__MSDOS__) \
+    || defined (__DJGPP__) || defined (__OS2__)
+#  define HAVE_DOS_BASED_FILE_SYSTEM
+#  ifndef DIR_SEPARATOR_2 
+#    define DIR_SEPARATOR_2 '\\'
+#  endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+#  define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else
+#  define IS_DIR_SEPARATOR(ch) \
+     (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif
+
 /* Name of temporary file.
    mktemp requires 6 trailing X's.  */
 #define TEMP_FILE "ccXXXXXX"
 #define TEMP_FILE_LEN (sizeof(TEMP_FILE) - 1)
 
-#if !defined(_WIN32) || defined(__CYGWIN__)
+#if !defined(_WIN32) || defined(__CYGWIN__) || defined(__DJGPP__)
 
 /* Subroutine of choose_tmpdir.
    If BASE is non-NULL, return it.
    Otherwise it checks if DIR is a usable directory.
    If success, DIR is returned.
@@ -105,11 +120,11 @@ files in.
 char *
 choose_tmpdir (void)
 {
   if (!memoized_tmpdir)
     {
-#if !defined(_WIN32) || defined(__CYGWIN__)
+#if !defined(_WIN32) || defined(__CYGWIN__) || defined(__DJGPP__)
       const char *base = 0;
       char *tmpdir;
       unsigned int len;
       
 #ifdef VMS
@@ -141,11 +156,12 @@ choose_tmpdir (void)
       /* Append DIR_SEPARATOR to the directory we've chosen
 	 and return it.  */
       len = strlen (base);
       tmpdir = XNEWVEC (char, len + 2);
       strcpy (tmpdir, base);
-      tmpdir[len] = DIR_SEPARATOR;
+      if (len > 0 && !IS_DIR_SEPARATOR(tmpdir[len - 1]))
+        tmpdir[len] = DIR_SEPARATOR;
       tmpdir[len+1] = '\0';
       memoized_tmpdir = tmpdir;
 #else /* defined(_WIN32) && !defined(__CYGWIN__) */
       DWORD len;
 
