* defs.h: Fix cntl-C to read from the Windows message queue.

	Add prototypes for make_final_cleanup (and the other cleanup
	routines.
	* remote-e7000.c: Fix sync code to timeout if unable to sync.
	Change sync code to report status while trying to sync-up
	with hardware.  Add debugging output and document.
	* ser-e7kpc.c: Swap order of len & offset to match implementation.
	Add debugging output and document.
	* serial.c: Add debugging output.
	* top.c: Add call to do_final_cleanups.
	Remove conditionals preventing Win32 from getting SIGQUIT.
	* utils.c: (*_cleanup): Modify cleanup routines to accept a cleanup
	chain as a parameter.  Extract this generic code from the cleanup
	routines into separate funtions (*_my_cleanup).  Keep old
	functionality by passing "cleanup_chain" to the new funtions.
	Define the cleanup chain "final_cleanup_chain" to be a cleanup
	chain which will be executed only when gdb exits.  Add functions
	(*_final_cleanup) to match the original (*_cleanup) functions.
	(pollquit, quit, notice_quit): Fix to read cntl-C from the
	Windows message queue.

6 files changed, 351 insertions, 47 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 24d3f1f..48cc750 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,27 @@
+
+Tue Feb 11 22:24:39 1997  Dawn Perchik  <dawn@cygnus.com>
+
+	* defs.h: Fix cntl-C to read from the Windows message queue.
+	Add prototypes for make_final_cleanup (and the other cleanup
+	routines.
+	* remote-e7000.c: Fix sync code to timeout if unable to sync.
+	Change sync code to report status while trying to sync-up 
+	with hardware.  Add debugging output and document.
+	* ser-e7kpc.c: Swap order of len & offset to match implementation.
+	Add debugging output and document.
+	* serial.c: Add debugging output.
+	* top.c: Add call to do_final_cleanups.
+	Remove conditionals preventing Win32 from getting SIGQUIT.
+	* utils.c: (*_cleanup): Modify cleanup routines to accept a cleanup
+	chain as a parameter.  Extract this generic code from the cleanup 
+	routines into separate funtions (*_my_cleanup).  Keep old 
+	functionality by passing "cleanup_chain" to the new funtions.  
+	Define the cleanup chain "final_cleanup_chain" to be a cleanup 
+	chain which will be executed only when gdb exits.  Add functions 
+	(*_final_cleanup) to match the original (*_cleanup) functions.
+	(pollquit, quit, notice_quit): Fix to read cntl-C from the 
+	Windows message queue.
+
 start-sanitize-m32r
 Tue Feb 11 15:36:31 1997  Doug Evans  <dje@canuck.cygnus.com>
 
diff --git a/gdb/defs.h b/gdb/defs.h
index 039bb6a..b8bb15e 100644
--- a/gdb/defs.h
+++ b/gdb/defs.h
@@ -96,8 +96,8 @@ extern void quit PARAMS ((void));
 
 #ifdef QUIT
 /* do twice to force compiler warning */
-#define FIXME "FIXME"
-#define FIXME "ignoring redefinition of QUIT"
+#define QUIT_FIXME "FIXME"
+#define QUIT_FIXME "ignoring redefinition of QUIT"
 #else
 #define QUIT { \
   if (quit_flag) quit (); \
@@ -230,8 +230,12 @@ extern void init_malloc PARAMS ((void *));
 extern void request_quit PARAMS ((int));
 
 extern void do_cleanups PARAMS ((struct cleanup *));
+extern void do_final_cleanups PARAMS ((struct cleanup *));
+extern void do_my_cleanups PARAMS ((struct cleanup *, struct cleanup *));
 
 extern void discard_cleanups PARAMS ((struct cleanup *));
+extern void discard_final_cleanups PARAMS ((struct cleanup *));
+extern void discard_my_cleanups PARAMS ((struct cleanup *, struct cleanup *));
 
 /* The bare make_cleanup function is one of those rare beasts that
    takes almost any type of function as the first arg and anything that
@@ -247,10 +251,18 @@ make_cleanup PARAMS ((void (*function) (void *), void *));
    wrong.  */
 
 extern struct cleanup *make_cleanup ();
+extern struct cleanup *
+make_final_cleanup PARAMS ((void (*function) (void *), void *));
+extern struct cleanup *
+make_my_cleanup PARAMS ((struct cleanup *, void (*function) (void *), void *));
 
 extern struct cleanup *save_cleanups PARAMS ((void));
+extern struct cleanup *save_final_cleanups PARAMS ((void));
+extern struct cleanup *save_my_cleanups PARAMS ((struct cleanup *));
 
 extern void restore_cleanups PARAMS ((struct cleanup *));
+extern void restore_final_cleanups PARAMS ((struct cleanup *));
+extern void restore_my_cleanups PARAMS ((struct cleanup *, struct cleanup *));
 
 extern void free_current_contents PARAMS ((char **));
 
@@ -342,6 +354,10 @@ extern char* paddr PARAMS ((t_addr addr));
 
 extern char* preg PARAMS ((t_reg reg));
 
+extern char* paddr_nz PARAMS ((t_addr addr));
+
+extern char* preg_nz PARAMS ((t_reg reg));
+
 extern void fprintf_symbol_filtered PARAMS ((GDB_FILE *, char *,
 					     enum language, int));
 
@@ -538,17 +554,17 @@ enum val_prettyprint
 /* This is to make sure that LONGEST is at least as big as CORE_ADDR.  */
 
 #define LONGEST BFD_HOST_64_BIT
+#define ULONGEST BFD_HOST_U_64_BIT
 
 #else /* No BFD64 */
 
-/* LONGEST should not be a typedef, because "unsigned LONGEST" needs to work.
-   CC_HAS_LONG_LONG is defined if the host compiler supports "long long" */
-
 #ifndef LONGEST
 #  ifdef CC_HAS_LONG_LONG
 #    define LONGEST long long
+#    define ULONGEST unsigned long long
 #  else
 #    define LONGEST long
+#    define ULONGEST unsigned long
 #  endif
 #endif
 
@@ -819,7 +835,7 @@ extern void set_endian_from_file PARAMS ((bfd *));
 
 extern LONGEST extract_signed_integer PARAMS ((void *, int));
 
-extern unsigned LONGEST extract_unsigned_integer PARAMS ((void *, int));
+extern ULONGEST extract_unsigned_integer PARAMS ((void *, int));
 
 extern int extract_long_unsigned_integer PARAMS ((void *, int, LONGEST *));
 
@@ -827,7 +843,7 @@ extern CORE_ADDR extract_address PARAMS ((void *, int));
 
 extern void store_signed_integer PARAMS ((void *, int, LONGEST));
 
-extern void store_unsigned_integer PARAMS ((void *, int, unsigned LONGEST));
+extern void store_unsigned_integer PARAMS ((void *, int, ULONGEST));
 
 extern void store_address PARAMS ((void *, int, CORE_ADDR));
 
@@ -936,7 +952,7 @@ extern void store_floating PARAMS ((void *, int, DOUBLEST));
 
 extern CORE_ADDR push_bytes PARAMS ((CORE_ADDR, char *, int));
 
-extern CORE_ADDR push_word PARAMS ((CORE_ADDR, unsigned LONGEST));
+extern CORE_ADDR push_word PARAMS ((CORE_ADDR, ULONGEST));
 
 /* Some parts of gdb might be considered optional, in the sense that they
    are not essential for being able to build a working, usable debugger
@@ -1047,4 +1063,13 @@ extern int use_windows;
 #define ROOTED_P(X) (SLASH_P((X)[0]))
 #endif
 
+/* On some systems, PIDGET is defined to extract the inferior pid from
+   an internal pid that has the thread id and pid in seperate bit
+   fields.  If not defined, then just use the entire internal pid as
+   the actual pid. */
+
+#ifndef PIDGET
+#define PIDGET(pid) (pid)
+#endif
+
 #endif /* #ifndef DEFS_H */
diff --git a/gdb/remote-e7000.c b/gdb/remote-e7000.c
index 7088e8b..ccdcc35 100644
--- a/gdb/remote-e7000.c
+++ b/gdb/remote-e7000.c
@@ -47,6 +47,9 @@
 #include "symfile.h"
 #include <time.h>
 
+//#define DEBUGIFY
+#include "debugify.h"
+
 #if 1
 #define HARD_BREAKPOINTS	/* Now handled by set option. */
 #define BC_BREAKPOINTS use_hard_breakpoints
@@ -57,6 +60,8 @@
 #define ACK  0x06
 #define CTRLZ 0x1a
 
+extern void notice_quit PARAMS ((void));
+
 extern void report_transfer_performance PARAMS ((unsigned long,
 						 time_t, time_t));
 
@@ -125,6 +130,7 @@ puts_e7000debug (buf)
 
   if (remote_debug)
     printf("Sending %s\n", buf);
+  DBG(("Sending %s; waiting for echo...\n", buf));
 
   if (SERIAL_WRITE (e7000_desc, buf, strlen (buf)))
     fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
@@ -134,6 +140,7 @@ puts_e7000debug (buf)
   if (!using_pc)
 #endif
     expect (buf);
+  DBG(("Got echo!n"));
 }
 
 static void
@@ -532,7 +539,7 @@ or \t\ttarget e7000 tcp_remote <host>[:<port>]\n\
 or \t\ttarget e7000 pc\n");
 	}
 
-#if !defined(__GO32__) && !defined(__WIN32__)
+#if !defined(__GO32__) && !defined(_WIN32)
       /* FIXME!  test for ':' is ambiguous */
       if (n == 1 && strchr (dev_name, ':') == 0)
 	{
@@ -557,6 +564,8 @@ e7000_open (args, from_tty)
   int loop;
   int sync;
   int serial_flag;
+  int try=0;
+  int quit_trying=20;
 
   target_preopen (from_tty);
 
@@ -567,7 +576,9 @@ e7000_open (args, from_tty)
   e7000_desc = SERIAL_OPEN (dev_name);
 
   if (!e7000_desc)
-    perror_with_name (dev_name);
+  {
+      error ("Unable to open target or file not found: %s\n", dev_name);
+  }
 
   SERIAL_SETBAUDRATE (e7000_desc, baudrate);
   SERIAL_RAW (e7000_desc);
@@ -576,7 +587,7 @@ e7000_open (args, from_tty)
   sync = 0;
   loop =  0;
   putchar_e7000 (CTRLC);
-  while (!sync)
+  while (!sync && ++try <= quit_trying)
     {
       int c;
 
@@ -585,7 +596,12 @@ e7000_open (args, from_tty)
 
       write_e7000 ("\r");
       c = SERIAL_READCHAR (e7000_desc, 1);
-      while (c != SERIAL_TIMEOUT)
+
+      /* FIXME!  this didn't seem right->  while (c != SERIAL_TIMEOUT)
+       * we get stuck in this loop ...
+       * We may never timeout, and never sync up :-(
+       */
+      while (!sync && c != SERIAL_TIMEOUT)
 	{
 	  /* Dont echo cr's */
 	  if (from_tty && c != '\r')
@@ -593,6 +609,7 @@ e7000_open (args, from_tty)
 	      putchar (c);
 	      fflush (stdout);
 	    }
+	  /* Shouldn't we either break here, or check for sync in inner loop? */
 	  if (c == ':')
 	    sync = 1;
 
@@ -605,14 +622,30 @@ e7000_open (args, from_tty)
 	  QUIT ;
 
 
+	  /* FIXME!  with this logic, you might never break out of this loop!
+	   * Changed to count tries and treat reads as TIMEOUTS
+	   * In windows version, you never timeout cuz always read 1 char!
+	   */
 	  if (quit_flag)
 	    {
 	      putchar_e7000 (CTRLC);
-	      quit_flag = 0;
+	      /* Was-> quit_flag = 0; */
+	      c = SERIAL_TIMEOUT;
+	      quit_trying = try+1;  /* we don't want to try anymore */
 	    }
-	  c = SERIAL_READCHAR (e7000_desc, 1);
+	  else
+	      c = SERIAL_READCHAR (e7000_desc, 1);
 	}
     }
+
+  if (!sync)
+  {
+      if (from_tty)
+	printf_unfiltered ("Giving up after %d tries...\n",try);
+      error ("Unable to syncronize with target.\n");
+      return;
+  }
+
   puts_e7000debug ("\r");
 
   expect_prompt ();
@@ -681,11 +714,20 @@ e7000_resume (pid, step, sig)
 
 #ifdef GDB_TARGET_IS_H8300
 
-char *want = "PC=%p CCR=%c\n\
+char *want_h8300h = "PC=%p CCR=%c\n\
+ ER0 - ER3  %0 %1 %2 %3\n\
+ ER4 - ER7  %4 %5 %6 %7\n";
+
+char *want_nopc_h8300h = "%p CCR=%c\n\
+ ER0 - ER3  %0 %1 %2 %3\n\
+ ER4 - ER7  %4 %5 %6 %7";
+
+char *want_h8300s = "PC=%p CCR=%c\n\
+ MACH=\n\
  ER0 - ER3  %0 %1 %2 %3\n\
  ER4 - ER7  %4 %5 %6 %7\n";
 
-char *want_nopc = "%p CCR=%c\n\
+char *want_nopc_h8300s = "%p CCR=%c EXR=%9\n\
  ER0 - ER3  %0 %1 %2 %3\n\
  ER4 - ER7  %4 %5 %6 %7";
 
@@ -871,7 +913,7 @@ e7000_fetch_registers ()
   else
      fetch_regs_from_dump (gch, want);
 #else
-  fetch_regs_from_dump (gch, want);
+  fetch_regs_from_dump (gch, h8300smode ? want_h8300s : want_h8300h);
 #endif
 
 
@@ -2015,7 +2057,7 @@ e7000_wait (pid, status)
   else
      fetch_regs_from_dump (gch, want_nopc);
 #else
-  fetch_regs_from_dump (gch, want_nopc);
+  fetch_regs_from_dump (gch, h8300smode ? want_nopc_h8300s : want_nopc_h8300h);
 #endif
 
   /* And supply the extra ones the simulator uses */
diff --git a/gdb/ser-e7kpc.c b/gdb/ser-e7kpc.c
index abe855b..7f6979f 100644
--- a/gdb/ser-e7kpc.c
+++ b/gdb/ser-e7kpc.c
@@ -18,20 +18,31 @@
    along with this program; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 
-#if defined(__GO32__) || defined(__WIN32__)
-#if defined(__WIN32__)
-//#define KERNEL
-//#define STRICT
-//#include <windows.h>
+//#define DEBUGIFY
+#include "debugify.h"
+
+#define RMT_DBG(x) if (remote_debug) printf_unfiltered x
+
+
+#if defined(__GO32__) || defined(_WIN32)
+#if defined(_WIN32)
 /* we define the 32-bit calls which thunk to 16-bit dll calls 
  */
 #include "win-e7kpc.h"
-/* msvc uses strnicmp instead */
+#include "target.h"
+#ifdef _MSC_VER
+/* msvc uses strnicmp instead of strncasecmp */
 #define strncasecmp strnicmp
+#define W32SUT_32
+#include "windefs.h"
+#include "w32sut.h"
+#endif
+#include "gdbwin.h"
+
 #else
 #include <sys/dos.h>
 #include "defs.h"
-#endif
+#endif /* _WIN32 */
 #include "serial.h"
 
 
@@ -88,22 +99,101 @@ static unsigned long pon;
 static unsigned long irqtop;
 static unsigned long board_at;
 
-#ifdef __WIN32__
-// These routines are normally part of the go32 dos extender.
-// We redefine them here to be calls into their Windoze equivs.
+#ifdef _WIN32
+/* These routines are normally part of the go32 dos extender.
+ * We redefine them here to be calls into their Windoze equivs. */
 static void dosmemget(int offset, int length, void *buffer);
 static void dosmemput(const void *buffer, int length, int offset);
 
-void dosmemget(int offset, int length, void *buffer)
+/* dll entry points for w32se7kpc.dll; call kernel32 to thunk for us */
+typedef BOOL (APIENTRY * PUTREGISTER) (
+	HANDLE hModule,
+        LPCSTR lpsz16BitDLL,
+	LPCSTR lpszInitName,
+	LPCSTR lpszProcName,
+	UT32PROC * ppfn32Thunk,
+	FARPROC pfnUT32Callback,
+	LPVOID lpBuff
+	);
+
+/* dll entry points for w95e7kpc.dll and w31e7kpc.dll */
+HANDLE hWine7kpc = 0;
+
+typedef int (APIENTRY * PWIN_LOAD_E7KPC) (void);
+typedef void (APIENTRY * PWIN_UNLOAD_E7KPC) (void);
+typedef void (APIENTRY * PWIN_MEM_GET) (unsigned char *buf, int len, int offset);
+typedef void (APIENTRY * PWIN_MEM_PUT) (unsigned char *buf, int len, int offset);
+typedef void (APIENTRY * PWIN_REMOTE_DEBUG) (int val);
+
+PWIN_LOAD_E7KPC pwin_load_e7kpc=NULL;
+PWIN_UNLOAD_E7KPC pwin_unload_e7kpc=NULL;
+PWIN_MEM_GET pwin_mem_get=NULL;
+PWIN_MEM_PUT pwin_mem_put=NULL;
+PWIN_REMOTE_DEBUG pwin_remote_debug=NULL;
+
+static int last_remote_debug = 0;
+static int wine7kpc_loaded = 0;
+static void win_unload_e7kpc (void);
+
+static int win_load_e7kpc (void)
 {
-    win_mem_get(buffer, length, offset);
+    if (pwin_load_e7kpc && !wine7kpc_loaded)
+    {
+      wine7kpc_loaded = pwin_load_e7kpc();
+      if (wine7kpc_loaded)
+	  make_final_cleanup(win_unload_e7kpc, 0);
+    }
+    return wine7kpc_loaded;
 }
-void dosmemput(const void *buffer, int length, int offset)
+
+static void win_unload_e7kpc (void)
 {
-    win_mem_put (buffer, length, offset);
+    DBG(("win_unload_e7kpc\n"));
+    if (pwin_unload_e7kpc && wine7kpc_loaded)
+      pwin_unload_e7kpc();
+    wine7kpc_loaded = 0;
 }
 
-#endif
+static void win_mem_get (unsigned char *buf, int offset, int len)
+{
+    DBG(("win_mem_get(&buf=<x%x> offset=<x%x> len=<%d>)\n", buf, offset, len));
+    if (remote_debug!=last_remote_debug && pwin_remote_debug)
+    {
+	//DBG(("calling pwin_remote_debug\n"));
+	pwin_remote_debug(remote_debug);
+        last_remote_debug=remote_debug;
+    }
+    if (pwin_mem_get) 
+    {
+	//DBG(("calling pwin_mem_get\n"));
+        pwin_mem_get (buf, offset, len);
+    }
+    //DBG(("leaving win_mem_get; buf=<%s>\n", buf));
+}
+
+static void win_mem_put (unsigned char *buf, int offset, int len)
+{
+    DBG(("win_mem_put(buf=<%s> offset=<x%x> len=<%d>)\n", buf, offset, len));
+    if (remote_debug!=last_remote_debug && pwin_remote_debug)
+    {
+	pwin_remote_debug(remote_debug);
+        last_remote_debug=remote_debug;
+    }
+    if (pwin_mem_put)
+      pwin_mem_put (buf, offset, len);
+}
+
+static void dosmemget(int offset, int length, void *buffer)
+{
+    win_mem_get(buffer, offset, length);
+}
+
+static void dosmemput(const void *buffer, int length, int offset)
+{
+    win_mem_put((unsigned char*)buffer, offset, length);
+}
+
+#endif /* _WIN32 */
 
 #define SET_BYTE(x,y)   { char _buf = y;dosmemput(&_buf,1, x);}
 #define SET_WORD(x,y)   { short _buf = y;dosmemput(&_buf,2, x);}
@@ -132,6 +222,7 @@ e7000pc_init ()
 
   int try;
   
+  DBG(("e7000pc_init()\n"));
   for (try = 0; sigs[try].sw; try++)
 
     {
@@ -145,9 +236,13 @@ e7000pc_init ()
       pon = board_at + OFF_PON;	      
       irqtop = board_at + OFF_IRQTOP;
       irqtod = board_at + OFF_IRQTOD;
-      
+
+      RMT_DBG(("e7000pc_init: looking for board's signature, try=%d\n", try));
+
       val = GET_WORD (ready);
 
+      //DBG(("e7000pc_init: GET_WORD returns x%x\n", val));
+
       if (val == (0xaaa0  | sigs[try].sw))
 	{
 	  if (GET_BYTE (pon) & 0xf)
@@ -157,15 +252,18 @@ e7000pc_init ()
 
 	      SET_BYTE (irqtop, 1); /* Disable interrupts from e7000 */
 	      SET_WORD (ready, 1);
+              DBG(("Yippie!  Connected :-)\n"));
 	      printf_filtered ("\nConnected to the E7000PC at address 0x%x\n", 
 			       sigs[try].addr);
 	      return 1;	      
 	    }
+          DBG(("Bummer!  e7000pc not on :-(\n"));
 	  error ("The E7000 PC board is working, but the E7000 is turned off.\n");
 	  return 0;
 	}
     }
 
+  DBG(("Bummer!  Can't connect :-(\n"));
   error ("GDB cannot connect to the E7000 PC board, check that it is installed\n\
 and that the switch settings are correct.  Some other DOS programs can \n\
 stop the board from working.  Try starting from a very minimal boot, \n\
@@ -185,6 +283,7 @@ e7000_get ()
   static char pbuf[1000];
   char tmp[1000];
   int x;
+  DBG(("e7000_get()\n"));
   if (pbuf_index < pbuf_size) 
     {
       x = pbuf[pbuf_index++];
@@ -199,6 +298,10 @@ e7000_get ()
       /* Tell the E7000 we've eaten */
       SET_BYTE(fb,0);	
       /* Swap it around */
+/* FIXME!  We get in an infinite loop inside e7000_open...
+ * This is called from dosasync_readchar
+ * called from remote-e7000.c trying to sync up.
+ */
       for (i = 0; i < pbuf_size; i++) 
 	{
 	  pbuf[i] = tmp[i^1];
@@ -224,20 +327,22 @@ dosasync_read (fd, buf, len, timeout)
   long now;
   long then;
   int i = 0;
-  int p;
 
+  DBG(("dosasync_read(fd=x%x,buf,len=x%x,timeout=x%x)\n",fd,len,timeout));
   /* Then look for some more if we're still hungry */
   time (&now);
   then = now + timeout;
   while (i < len)
     {
       int ch = e7000_get();
+      //DBG(("%d: e7000_get gotta x%x\n", i, ch\n"));
       
       /* While there's room in the buffer, and we've already
-	 read the stuff in, suck it over */
+       * read the stuff in, suck it over */
       if (ch != -1) 
 	{
 	  buf[i++] = ch;
+	  //DBG(("e7000_get got x%x; before loop2: len=x%x, pbuf_index=x%x, pbuf_size=x%x\n", ch, len, pbuf_index, pbuf_size));
 	  while (i < len && pbuf_index < pbuf_size )
 	    {
 	      ch = e7000_get();
@@ -249,13 +354,18 @@ dosasync_read (fd, buf, len, timeout)
 
       time (&now);
 
-      if (timeout == 0)
-	return i;
-      if (now >= then && timeout > 0)
+      if (timeout == 0 || (now >= then && timeout > 0))
 	{
+/* We timeout here but return i anyway...  
+ * were we supposed to send a TIMEOUT ?
+ * While syncing, len = 1 and timeout=1..
+ * so always take this path and return 1 char. 
+ */
+	  DBG(("timeout; read x%x chars\n", i));
 	  return i;
 	}
     }
+  //DBG(("Yay! read x%x chars\n", len));
   return len;
 }
 
@@ -269,6 +379,7 @@ dosasync_write (fd, buf, len)
   int i;
   char dummy[1000];  
 
+  DBG(("dosasync_write(fd=x%x,buf=x%x,len=x%x)\n",fd,buf,len));
   
   /* Construct copy locally */
   ((short *)dummy)[0] = CMD_CI;
@@ -293,28 +404,109 @@ dosasync_write (fd, buf, len)
   return len;
 }
 
+
+#ifdef _WIN32
+static int 
+load_wine7kpc(void)
+{
+  char dll[64];
+
+  DBG(("load_wine7kpc()\n"));
+  if (win_host()==winnt)
+    {
+        printf_filtered( "e7000pc not supported on this host.\n" );
+        return 0;
+    }
+  if (win_host()==win32s)
+      strcpy(dll, "w31e7kpc.Dll");
+  else if (win_host()==win95)
+      strcpy(dll, "w95e7kpc.Dll");
+  else return 0;
+
+  /* load dll for windows support of e7000pc */
+  DBG(("LoadLibrary(%s)\n",dll));
+  hWine7kpc = LoadLibrary (dll);
+  if (!hWine7kpc)
+    {
+        DBG(("LoadLibrary(%s) failed\n",dll));
+        printf_filtered( "Error: unable to load %s.\n",dll);
+        return 0;
+    }
+  pwin_load_e7kpc = (PWIN_LOAD_E7KPC) GetProcAddress (hWine7kpc, "win_load_e7kpc");
+  if (!pwin_load_e7kpc)
+    {
+        DBG(("!pwin_load_e7kpc\n"));
+        printf_filtered( "Error: unable to resolve win_load_e7kpc.\n" );
+        return 0;
+    }
+  pwin_unload_e7kpc = (PWIN_UNLOAD_E7KPC) GetProcAddress (hWine7kpc, "win_unload_e7kpc");
+  if (!pwin_unload_e7kpc)
+    {
+        DBG(("!pwin_unload_e7kpc\n"));
+        printf_filtered( "Error: unable to resolve win_unload_e7kpc.\n" );
+        return 0;
+    }
+  pwin_mem_get = (PWIN_MEM_GET) GetProcAddress (hWine7kpc, "win_mem_get");
+  if (!pwin_mem_get)
+    {
+        DBG(("!pwin_mem_get\n"));
+        printf_filtered( "Error: unable to resolve win_mem_get.\n" );
+        return 0;
+    }
+  pwin_mem_put= (PWIN_MEM_PUT) GetProcAddress (hWine7kpc, "win_mem_put");
+  if (!pwin_mem_put)
+    {
+        DBG(("!pwin_mem_put\n"));
+        printf_filtered( "Error: unable to resolve win_mem_put.\n" );
+        return 0;
+    }
+  pwin_remote_debug= (PWIN_REMOTE_DEBUG) GetProcAddress (hWine7kpc, "win_remote_debug");
+  if (!pwin_remote_debug)
+    {
+        DBG(("!pwin_remote_debug\n"));
+        printf_filtered( "Error: unable to resolve win_remote_debug.\n" );
+        return 0;
+    }
+  DBG(("load_wine7kpc Done! :-)\n"));
+  return 1;
+}
+#endif /* _WIN32 */
+
 static int
 e7000pc_open (scb, name)
      serial_t scb;
      const char *name;
 {
+  DBG(("e7000pc_open\n"));
   if (strncasecmp (name, "pc", 2) != 0)
     {
       errno = ENOENT;
       return -1;
     }
-#ifdef __WIN32__
+#ifdef _WIN32
+  if (!load_wine7kpc()) /* load windows dll for e7kpc support */
+    {
+        DBG(("Error! load_wine7kpc failed\n"));
+        printf_filtered("Failed to initialize dll for e7000pc support.\n" );
+        return -1;
+    }
+  //DBG(("calling win_load_e7kpc\n"));
   if (win_load_e7kpc () != 0)
     {
       errno = ENOENT;
       return -1;
     }
-#endif
+#endif /* _WIN32 */
+  //DBG(("calling e7000pc_init\n"));
   scb->fd = e7000pc_init ();
 
   if (!scb->fd)
+  {
+    DBG(("Error! !scb->fd\n"));
     return -1;
+  }
 
+  DBG(("e7000pc_open done! :-)\n"));
   return 0;
 }
 
@@ -339,8 +531,12 @@ e7000pc_readchar (scb, timeout)
 {
   char buf;
 
+ DBG(("e7000pc_readchar\n"));
  top:
 
+  /* FIXME!  How does dosasync_read ever return 0?
+   * it always goes thru the loop once, so i>0
+   */
   if (dosasync_read (scb->fd, &buf, 1, timeout))
     {
       if (buf == 0) goto top;
@@ -362,6 +558,7 @@ e7000pc_get_tty_state (scb)
      serial_t scb;
 {
   struct e7000pc_ttystate *state;
+  DBG(("e7000pc_get_tty_state\n"));
 
   state = (struct e7000pc_ttystate *) xmalloc (sizeof *state);
 
@@ -408,6 +605,7 @@ e7000pc_write (scb, str, len)
      const char *str;
      int len;
 {
+  DBG(("e7000pc_write(scb,str=%s,len=x%x)\n",str,len));
   dosasync_write (scb->fd, str, len);
 
   return 0;
@@ -417,7 +615,8 @@ static void
 e7000pc_close (scb)
      serial_t scb;
 {
-#ifdef __WIN32__
+  DBG(("e7000pc_close\n"));
+#ifdef _WIN32
   win_unload_e7kpc ();
 #endif
 }
@@ -453,4 +652,4 @@ _initialize_ser_e7000pc ()
 {
 
 }
-#endif
+#endif /* defined(__GO32__) || defined(_WIN32) */
diff --git a/gdb/serial.c b/gdb/serial.c
index c30fda6..9e9ec82 100644
--- a/gdb/serial.c
+++ b/gdb/serial.c
@@ -23,6 +23,10 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "gdb_string.h"
 #include "gdbcmd.h"
 
+//#define DEBUGIFY
+#include "debugify.h"
+
+
 /* Linked list of serial I/O handlers */
 
 static struct serial_ops *serial_ops_list = NULL;
@@ -206,11 +210,13 @@ serial_interface_lookup (name)
      char *name;
 {
   struct serial_ops *ops;
+  DBG(("serial_interface_lookup(%s)\n",name));
 
   for (ops = serial_ops_list; ops; ops = ops->next)
     if (strcmp (name, ops->name) == 0)
       return ops;
 
+  DBG(("serial_interface_lookup: %s not found!\n",name));
   return NULL;
 }
 
@@ -231,10 +237,12 @@ serial_open (name)
   serial_t scb;
   struct serial_ops *ops;
 
+  DBG(("serial_open\n"));
   for (scb = scb_base; scb; scb = scb->next)
     if (scb->name && strcmp (scb->name, name) == 0)
       {
 	scb->refcnt++;
+        DBG(("serial_open: scb %s found\n", name));
 	return scb;
       }
 
@@ -248,7 +256,10 @@ serial_open (name)
     ops = serial_interface_lookup ("hardwire");
 
   if (!ops)
+  {
+    DBG(("serial_open: !ops; returning NULL\n"));
     return NULL;
+  }
 
   scb = (serial_t)xmalloc (sizeof (struct _serial_t));
 
@@ -260,6 +271,7 @@ serial_open (name)
   if (scb->ops->open(scb, name))
     {
       free (scb);
+      DBG(("serial_open: scb->ops->open failed!\n"));
       return NULL;
     }
 
@@ -275,10 +287,12 @@ serial_open (name)
       serial_logfp = fopen (serial_logfile, "w");
       if (serial_logfp == NULL)
 	{
+          DBG(("serial_open: unable to open serial logfile %s!\n",serial_logfile));
 	  perror_with_name (serial_logfile);
 	}
     }
 
+  DBG(("serial_open: Done! :-)\n"));
   return scb;
 }
 
@@ -288,6 +302,7 @@ serial_fdopen (fd)
 {
   serial_t scb;
   struct serial_ops *ops;
+  DBG(("serial_fdopen\n"));
 
   for (scb = scb_base; scb; scb = scb->next)
     if (scb->fd == fd)
@@ -413,6 +428,7 @@ connect_command (args, fromtty)
   char cur_esc = 0;
   serial_ttystate ttystate;
   serial_t port_desc;		/* TTY port */
+  DBG(("connect_command\n"));
 
   dont_repeat();
 
diff --git a/gdb/top.c b/gdb/top.c
index 2e1098c..3afa8c9 100644
--- a/gdb/top.c
+++ b/gdb/top.c
@@ -571,7 +571,6 @@ catch_errors (func, args, errstring, mask)
 
 /* Handler for SIGHUP.  */
 
-#ifndef _WIN32
 static void
 disconnect (signo)
 int signo;
@@ -581,7 +580,6 @@ int signo;
   signal (SIGHUP, SIG_DFL);
   kill (getpid (), SIGHUP);
 }
-#endif
 
 /* Just a little helper function for disconnect().  */
 
@@ -1899,11 +1897,9 @@ init_signals ()
      might be in memory, shared between the two).  Since we establish
      a handler for SIGQUIT, when we call exec it will set the signal
      to SIG_DFL for us.  */
-#ifndef _WIN32
   signal (SIGQUIT, do_nothing);
   if (signal (SIGHUP, do_nothing) != SIG_IGN)
     signal (SIGHUP, disconnect);
-#endif
   signal (SIGFPE, float_handler);
 
 #if defined(SIGWINCH) && defined(SIGWINCH_HANDLER)
@@ -2856,6 +2852,8 @@ quit_command (args, from_tty)
   if (write_history_p && history_filename)
     write_history (history_filename);
 
+  do_final_cleanups(ALL_CLEANUPS);	/* Do any final cleanups before exiting */
+
   exit (exit_code);
 }