path: root/misc/buildroot/toolchain/gdb/6.4/700-m68hc1x-20060122.patch

diff --exclude-from=exclude.lst -Nrup gdb-6.4/bfd/ChangeLog.M68HC11 gdb-6.4-m68hc1x/bfd/ChangeLog.M68HC11
--- gdb-6.4/bfd/ChangeLog.M68HC11	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/bfd/ChangeLog.M68HC11	Sun Jan 22 22:18:25 2006
@@ -0,0 +1,7 @@
+2006-01-21  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* elf32-m68hc1x.c: Include "alloca-conf.h"
+
+2004-02-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* opncls.c: Merge from mingw32 20031011 port.
diff --exclude-from=exclude.lst -Nrup gdb-6.4/bfd/elf32-m68hc1x.c gdb-6.4-m68hc1x/bfd/elf32-m68hc1x.c
--- gdb-6.4/bfd/elf32-m68hc1x.c	Mon Jun 20 20:12:07 2005
+++ gdb-6.4-m68hc1x/bfd/elf32-m68hc1x.c	Sat Jan 21 17:53:08 2006
@@ -1,5 +1,5 @@
 /* Motorola 68HC11/HC12-specific support for 32-bit ELF
-   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005
+   Copyright 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006
    Free Software Foundation, Inc.
    Contributed by Stephane Carrez (stcarrez@nerim.fr)
 
@@ -19,6 +19,7 @@ You should have received a copy of the G
 along with this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
 
+#include "alloca-conf.h"
 #include "bfd.h"
 #include "sysdep.h"
 #include "bfdlink.h"
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/ChangeLog.M68HC11 gdb-6.4-m68hc1x/gdb/ChangeLog.M68HC11
--- gdb-6.4/gdb/ChangeLog.M68HC11	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/ChangeLog.M68HC11	Sat Jan 21 17:14:12 2006
@@ -0,0 +1,147 @@
+2006-01-21  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* m68hc11-rom.c (dbug_xfer_memory): Use gdb_byte
+	* remote-bdm12.c (gdbbdm12_insert_breakpoint): Use gdb_byte
+	(gdbbdm12_remove_breakpoint): Likewise.
+	(gdbbdm12_xfer_inferior_memory): Likewise.
+	(gdbbdm12_fetch_register): Use regcache_raw_supply to set the
+	register in gdb's cache. Use register_size.
+	(gdbbdm12_store_register): Likewise.
+
+2004-08-05  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* ser-mingw.c (do_mingw_readchar): Use deprecated_ui_loop_hook instead of
+	ui_loop_hook
+
+2004-08-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* signals/signals.c (SIGTRAP): Define if not defined so that the
+	simulator works on mingw32.
+
+2004-08-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	Patch Savannah/3123:
+	From Marek Peca <marek@tynska.cuni.cz>:
+
+	* remote-bdm12.c (gdbbdm12_cntrl_c): Set stop requested flag.
+	(gdbbdm12_wait): Call gdbbdm12_stop here instead of from sig handler.
+	* remote-bdm12.c (gdbbdm12_stop): Clear stop requested flag.
+
+2004-08-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* remote-bdm12.c (gdbbdm12_create_inferior): Fix prototype.
+
+2004-08-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* remote-bdm12.c (gdbbdm12_fetch_register): Use DEPRECATED_REGISTER_RAW_SIZE.
+	(gdbbdm12_store_register): Likewise.
+
+2004-02-08  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* remote-bdm12.c (gdbbdm12_wait): Use TARGET_SIGNAL_SIGABRT,
+	TARGET_SIGNAL_INT, TARGET_SIGNAL_TRAP
+
+	* bdm12.c (bdm12_stop_reason): Use TARGET_SIGNAL_TRAP and
+	TARGET_SIGNAL_INT.
+
+2004-02-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* version.in: Bump to 2004-02-01
+
+2004-02-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* bdm12.h (bdm12_create_inferior): Update prototype.
+	Convert prototypes.
+	* bdm12.c (bdm12_create_inferior): Use bfd type.
+
+	* remote-bdm12.c (gdbbdm12_fetch_register): Use MAX_REGISTER_SIZE.
+	(gdbbdm12_store_register): Likewise.
+	(gdbbdm12_store_register): Use deprecated_read_register_gen.
+
+2004-02-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* configure.in, environ.c, environ.h, infcmd.c, inferior.h,
+	win32-nat.c, event-loop.c, event-loop.h, utils.c, top.c, ser-mingw.c,
+        set-mingw.h, ser-tcp.c, ser-unix.c, inferior.h:
+
+	Merge http://www.ming.org 20031011 gdb patch for Mingw32 host.
+
+2002-06-15  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* remote-bdm12.c (gdbbdm12_kill): Use null_ptid.
+	(gdbbdm12_load): Likewise.
+	(gdbbdm12_resume): Use PIDGET.
+	(gdbbdm12_wait): Update prototype.
+	(pass_command): Use target_fetch_register.
+
+2002-06-10  Martin Rod  <martin.rod@ct.cz>
+
+	* bdm12.c: Add small delay after RTS asserting (Linux)
+
+2001-10-14  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* bdm12.c: Don't compile under Mingw32 since serial line code is
+	not ported.
+	* remote-bdm12.c: Likewise.
+
+2001-09-28  Tim Housel	<thousel@usa.net>
+
+	* bdm12.c: New file (BDM12 pod communication support).
+	* bdm12.h: New file.
+	* remote-bdm12.c: New file (BDM12 gdb backend).
+	* bdm12_eraseflash.h: New file.
+	* bdm12_programflash.h: New file.
+	* Makefile.in (ALLDEPFILES): Add new files.
+
+2001-01-13  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* dsrec.c (load_srec): Use the LMA address when loading.
+
+2001-01-06  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* dsrec.c (load_srec): Use serial_write function to send
+	data on the serial line.
+	* srec.h (load_srec): Add serial_write parameter.
+
+2000-12-28  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* monitor.h (serial_write): New member.
+	* monitor.c (monitor_write): Use it if it is set.
+	(monitor_read_memory): Use monitor_write.
+
+2000-12-28  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* m68hc11-rom.c (set_gdbarch): New function.
+	(m68hc11_serial_write): New function.
+	(console_input): New function.
+	(do_console_input): New function.
+	(m68hc11_wait_filter): New function.
+	(init_buffalo_cmds): Install them.
+	(dbug_dumpregs): New function.
+	(dbug_xfer_memory): New function.
+	(init_dbug_cmds): New function.
+	(dbug_open): New function.
+	(_initialize_m68hc11_rom): Register DBUG monitor.
+
+2000-12-03  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* Makefile.in (m68hc11-tdep.o): Define dependencies.
+	(m68hc11-rom.o): Likewise.
+	(ALLDEPFILES): Add m68hc11-tdep.c
+	* m68hc11-rom.c: New file for 68HC11/68HC12 monitors.
+	* config/m68hc11/m68hc11.mt (TDEPFILES): Add files for monitor
+	support.
+
+2000-09-10  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* monitor.c (monitor_fetch_register): Fix allocation of zerobuf
+	and regbuf (from GDB cvs main branch).
+
+2000-09-10  Stephane Carrez  <Stephane.Carrez@worldnet.fr>
+
+	* monitor.c (monitor_write_memory): If setmem.resp_delim is set,
+	use a regular expression to check the write memory command.
+	(monitor_store_register): Likewise with setreg.resp_delim.
+	(monitor_open): Compile the setmem and setreg regular expressions.
+	* m68hc11-rom.c: New file for 68hc11 monitors support.
+	* config/m68hc11/m68hc11.mt (TDEPFILES): Add the monitor support.
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/bdm12.c gdb-6.4-m68hc1x/gdb/bdm12.c
--- gdb-6.4/gdb/bdm12.c	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/bdm12.c	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,1340 @@
+/* Target communications support for Kevin Ross' BDM12 pod for the 68HC12
+   Copyright 2001
+   Free Software Foundation, Inc.
+   Contributed by Tim Housel (thousel@usa.net)
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "gdbcore.h"
+#include "gdb_string.h"
+#include <fcntl.h>
+#include "frame.h"
+#include "inferior.h"
+#include "bfd.h"
+#include "symfile.h"
+#include "target.h"
+#include "gdbcmd.h"
+#include "objfiles.h"
+#include "gdb-stabs.h"
+#include <sys/types.h>
+#include <sys/time.h>
+#include <signal.h>
+#include "serial.h"
+#include "bdm12.h"
+#include "bdm12_eraseflash.h"
+#include "bdm12_programflash.h"
+
+#if defined(__CYGWIN32__) || defined(__MINGW32__)
+#include <windows.h>
+#include <io.h>
+#else
+/* assuming UNIX */
+#include <sys/ioctl.h>
+#endif
+
+#define xfree(ptr) free(ptr)
+
+#define BDM12_RTS_DELAY 1
+
+/* Prototypes for local functions */
+
+static int bdm12_eeprom_write (CORE_ADDR memaddr, char *buf, int len);
+
+static int bdm12_flash_write (CORE_ADDR memaddr, char *buf, int len);
+
+static int erase_flash(void);
+
+static int bdm12_put_packet (unsigned char *packet, int pktlen);
+
+static int bdm12_get_packet (unsigned char *packet, int pktlen);
+
+static void write_rts_state (int state);
+
+static int read_cts_state (void);
+
+static int valid_write_range (CORE_ADDR start_addr, CORE_ADDR end_addr);
+
+static int valid_read_range (CORE_ADDR start_addr, CORE_ADDR end_addr);
+
+static long diffms (struct timeval t1, struct timeval t2);
+
+/* serial descriptor for interface to BDM pod */
+static struct serial* ser_desc = NULL;
+
+/* since cygwin doesn't support the ioctls for manually mucking with the
+   RTS and CTS lines, we must use win32 calls. This provides a place to
+   store the windows handle */
+#if defined(__CYGWIN32__) || defined(__MINGW32__)
+static HANDLE win_ser_desc = INVALID_HANDLE_VALUE;
+#endif
+
+static unsigned char reg_page = 0;
+static unsigned int  reg_base = 0;
+static unsigned int ram_base = 0;
+static unsigned int eeprom_base = 0;
+static unsigned int flash_base = 0;
+static int num_breakpoints = 0;
+static int program_loaded = 0;
+static int flash_erased = 0;
+static int stopped = 0;
+static int singlestepped = 1;
+
+static CORE_ADDR breakpoint[BDM12_MAX_BREAKPOINTS] = {0, 0};
+
+struct memory_region_list
+  {
+    CORE_ADDR addr;
+    unsigned int size;
+    unsigned char* data;
+    struct memory_region_list* next;
+    struct memory_region_list* prev;
+  } flash_regions;
+
+struct memory_region_list *cur_region = &flash_regions;
+
+/* Open a connection to a remote debugger.
+   NAME is the filename used for communication.  */
+
+BDM12_RC
+bdm12_open (char **argv)
+{
+  char *ser_name;
+  unsigned char buf[5];
+  int erate, rc;
+
+  if (argv == NULL)
+    return BDM12_RC_FAIL;
+  if (argv[0] == NULL)
+    return BDM12_RC_FAIL;
+  if (argv[1] == NULL)
+    return BDM12_RC_FAIL;
+  if (argv[2] == NULL)
+    return BDM12_RC_FAIL;
+  if (argv[3] == NULL)
+    return BDM12_RC_FAIL;
+  if (argv[4] == NULL)
+    return BDM12_RC_FAIL;
+  if (argv[5] == NULL)
+    return BDM12_RC_FAIL;
+
+  ser_name = alloca (strlen (argv[0]) + 6); /* for "/dev/\0" */
+  if (!ser_name)
+    return BDM12_RC_FAIL;
+
+  strcpy (ser_name, "/dev/");
+  strcat (ser_name, argv[0]);
+  erate = atoi (argv[1]);
+  switch (erate)
+    {
+    case 1:
+      erate = BDM12_ECLOCK_1MHZ;
+      break;
+    case 2:
+      erate = BDM12_ECLOCK_2MHZ;
+      break;
+    case 4:
+      erate = BDM12_ECLOCK_4MHZ;
+      break;
+    case 8:
+      erate = BDM12_ECLOCK_8MHZ;
+      break;
+    default:
+      error ("bad value for target E clock rate - use 1, 2, 4, or 8)");
+      return BDM12_RC_FAIL;
+      break;
+    }
+
+  reg_base = strtoul (argv[2], NULL, 16);
+  if (reg_base & 0x7ff)
+    {
+      error ("bad value for target register base - should be on 2K boundary");
+      return BDM12_RC_FAIL;
+    }
+
+  ram_base = strtoul (argv[3], NULL, 16);
+  if (ram_base & 0x7ff)
+    {
+      error ("bad value for target RAM base - should be on 2K boundary");
+      return BDM12_RC_FAIL;
+    }
+
+  eeprom_base = strtoul (argv[4], NULL, 16);
+  if ((eeprom_base & 0x2ff) || !((eeprom_base & 0xfff) | 0xd00))
+    {
+      error ("bad value for target EEPROM base - should be on 4K boundary + 0xd00");
+      return BDM12_RC_FAIL;
+    }
+
+  flash_base = strtoul (argv[5], NULL, 16);
+  if (flash_base & 0x7fff)
+    {
+      error ("bad value for target FLASH base - should be on 32K boundary");
+      return BDM12_RC_FAIL;
+    }
+
+  reg_page = reg_base >> 8;
+
+  ser_desc = serial_open (ser_name);
+  if (!ser_desc)
+    {
+      error ("unable to open serial port");
+      return BDM12_RC_FAIL;
+    }
+
+#if defined(__CYGWIN32__)
+  win_ser_desc = (HANDLE) get_osfhandle (ser_desc->fd);
+#elif defined(__MINGW32__)
+  win_ser_desc = (HANDLE) ser_desc->fd;
+#endif
+
+  if (!ser_desc)
+    {
+      perror_with_name (ser_name);
+      return BDM12_RC_FAIL;
+    }
+
+  if (serial_setbaudrate (ser_desc, BDM12_BAUD_RATE))
+    {
+      serial_close (ser_desc);
+      perror_with_name (ser_name);
+      return BDM12_RC_FAIL;
+    }
+
+  serial_raw (ser_desc);
+
+  /* If there is something sitting in the buffer we might take it as a
+     response to a command, which would be bad.  */
+  serial_flush_input (ser_desc);
+
+  rc = 0;
+
+  /* synchronize the pod */
+  buf[0] = BDM12_CMD_SYNC;
+  rc = bdm12_put_packet (buf, 1);
+  /* if the first command doesn't work, bail */
+  if (rc)
+    return BDM12_RC_FAIL;
+
+  /* now just collect the errors for the next set of commands */
+
+  /* set the target parameters */
+  buf[0] = BDM12_CMD_EXT;
+  buf[1] = BDM12_CMD_EXT_SETPARAM;
+  buf[2] = erate;
+  buf[3] = 0; /* We don't need no steekin' delays, I hope ;-) */
+  buf[4] = 0;
+  rc += bdm12_put_packet (buf, 5);
+
+  /* reset the target */
+  buf[0] = BDM12_CMD_RESET;
+  rc += bdm12_put_packet (buf, 1);
+
+  /* make sure BDM is enabled */
+  buf[0] = BDM12_CMD_WRITE_BD_BYTE;
+  buf[1] = BDM12_BDM_HI;
+  buf[2] = BDM12_ENABLE_BDM_LO;
+  buf[3] = BDM12_INIT_ENABLE_BDM;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* map the registers */
+  buf[0] = BDM12_CMD_WRITE_BYTE;
+  buf[1] = 0;
+  buf[2] = BDM12_REG_INITRG;
+  buf[3] = reg_page;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* Let the POD know where we've mapped the registers */
+  buf[0] = BDM12_CMD_SET_REGBASE;
+  buf[1] = reg_page;
+  rc += bdm12_put_packet (buf, 2);
+
+  /* map RAM */
+  buf[0] = BDM12_CMD_WRITE_BYTE;
+  buf[2] = BDM12_REG_INITRM;
+  buf[3] = ram_base >> 8;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* map EEPROM */
+  buf[2] = BDM12_REG_INITEE;
+  buf[3] = ((eeprom_base >> 8) & 0xf0) | 0x1;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* map FLASH */
+  buf[2] = BDM12_REG_MISC;
+  buf[3] = 0x0d | (flash_base >> 14);
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* setup breakpoints */
+  buf[2] = BDM12_REG_BRKCT0;
+  buf[3] = BDM12_INIT_BRKCT0;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* setup breakpoints */
+  buf[2] = BDM12_REG_BRKCT1;
+  buf[3] = BDM12_INIT_BRKCT1;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  /* disable flash protection */
+  buf[2] = BDM12_REG_FEEMCR;
+  buf[3] = BDM12_INIT_FEEMCR;
+  buf[4] = buf[3];
+  rc += bdm12_put_packet (buf, 5);
+
+  if (rc)
+    return BDM12_RC_FAIL;
+
+  serial_flush_input (ser_desc);
+  return BDM12_RC_OK;
+}
+
+/* Clean up connection to a remote debugger.  */
+
+void
+bdm12_close (int quitting)
+{
+  if (ser_desc)
+    serial_close (ser_desc);
+  ser_desc = NULL;
+#if defined(__CYGWIN32__) || defined(__MINGW32__)
+  win_ser_desc = INVALID_HANDLE_VALUE;
+#endif
+  program_loaded = 0;
+  flash_erased = 0;
+  stopped = 0;
+
+  while (cur_region->prev != NULL)
+    {
+      if (cur_region->data)
+        xfree(cur_region->data);
+      if (cur_region->next)
+        xfree(cur_region->next);
+
+      cur_region = cur_region->prev;
+    }
+}
+
+/* Init processor state - for us just set the PC to _start from the bfd */
+BDM12_RC
+bdm12_create_inferior (bfd *abfd, char **argv, char **env)
+{
+  CORE_ADDR start = bfd_get_start_address (abfd);
+  unsigned char cmdbuf[2];
+
+  /* set the PC */
+  cmdbuf[0] = start >> 8;
+  cmdbuf[1] = start;
+  return (bdm12_store_register (HARD_PC_REGNUM, cmdbuf, 2) != 2);
+}
+
+/* Tell the remote machine to resume.  */
+
+int
+bdm12_resume (int step)
+{
+  unsigned char buf;
+  int rc;
+
+  if (step)
+    {
+      buf = BDM12_CMD_TRACE1;
+      singlestepped = 1;
+    }
+  else
+    {
+      buf = BDM12_CMD_GO;
+      singlestepped = 0;
+    }
+
+  if (!(rc = bdm12_put_packet (&buf, 1)))
+    stopped = 0;
+  return rc;
+}
+
+int
+bdm12_stop (void)
+{
+  BDM12_RC rc;
+  unsigned char buf = BDM12_CMD_BACKGROUND;
+
+  rc = bdm12_put_packet (&buf, 1);
+  if (rc == BDM12_RC_OK)
+    stopped = 1;
+  return !rc;
+}
+
+/* Read register */
+
+int
+bdm12_fetch_register (int regno, unsigned char* buf, int length)
+{
+  unsigned char cmdbuf[3];
+  int rc;
+
+  switch (regno)
+    {
+    case HARD_A_REGNUM:
+    case HARD_B_REGNUM:
+    case HARD_D_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_D;
+      break;
+    case HARD_X_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_X;
+      break;
+    case HARD_Y_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_Y;
+      break;
+    case HARD_SP_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_SP;
+      break;
+    case HARD_PC_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_PC;
+      break;
+    case HARD_PSW_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_BD_BYTE;
+      cmdbuf[1] = BDM12_BDM_HI;
+      cmdbuf[2] = BDM12_CCRSAV_BDM_LO;
+      break;
+    default:
+      return 0;
+    }
+
+  if (regno == HARD_PSW_REGNUM)
+    rc = bdm12_put_packet (cmdbuf, 3);
+  else
+    rc = bdm12_put_packet (cmdbuf, 1);
+
+  if (rc)
+    return 0;
+
+  rc = bdm12_get_packet (cmdbuf, 2);
+  if (rc)
+    return 0;
+
+  switch (regno)
+    {
+    case HARD_A_REGNUM:
+    case HARD_PSW_REGNUM:
+      buf[0] = 0;
+      buf[1] = cmdbuf[0];
+      break;
+    case HARD_B_REGNUM:
+      buf[0] = 0;
+      buf[1] = cmdbuf[1];
+      break;
+    default:
+      buf[0] = cmdbuf[0];
+      buf[1] = cmdbuf[1];
+      break;
+    }
+
+  return length;
+}
+
+/* Write register */
+
+int
+bdm12_store_register (int regno, unsigned char* buf, int length)
+{
+  unsigned char cmdbuf[5];
+  int rc = 0;
+
+  switch (regno)
+    {
+    case HARD_A_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_D;
+      rc += bdm12_put_packet (cmdbuf, 1);
+      rc += bdm12_get_packet (cmdbuf, 2);
+      cmdbuf[2] = cmdbuf[1];
+      cmdbuf[1] = buf[0];
+      cmdbuf[0] = BDM12_CMD_WRITE_D;
+      break;
+    case HARD_B_REGNUM:
+      cmdbuf[0] = BDM12_CMD_READ_D;
+      rc += bdm12_put_packet (cmdbuf, 1);
+      rc += bdm12_get_packet (cmdbuf, 2);
+      cmdbuf[2] = buf[1];
+      cmdbuf[1] = cmdbuf[0];
+      cmdbuf[0] = BDM12_CMD_WRITE_D;
+      break;
+    case HARD_D_REGNUM:
+      cmdbuf[0] = BDM12_CMD_WRITE_D;
+      cmdbuf[1] = buf[0];
+      cmdbuf[2] = buf[1];
+      break;
+    case HARD_X_REGNUM:
+      cmdbuf[0] = BDM12_CMD_WRITE_X;
+      cmdbuf[1] = buf[0];
+      cmdbuf[2] = buf[1];
+      break;
+    case HARD_Y_REGNUM:
+      cmdbuf[0] = BDM12_CMD_WRITE_Y;
+      cmdbuf[1] = buf[0];
+      cmdbuf[2] = buf[1];
+      break;
+    case HARD_SP_REGNUM:
+      cmdbuf[0] = BDM12_CMD_WRITE_SP;
+      cmdbuf[1] = buf[0];
+      cmdbuf[2] = buf[1];
+      break;
+    case HARD_PC_REGNUM:
+      cmdbuf[0] = BDM12_CMD_WRITE_PC;
+      cmdbuf[1] = buf[0];
+      cmdbuf[2] = buf[1];
+      break;
+    case HARD_PSW_REGNUM:
+      cmdbuf[0] = BDM12_CMD_WRITE_BD_BYTE;
+      cmdbuf[1] = BDM12_BDM_HI;
+      cmdbuf[2] = BDM12_CCRSAV_BDM_LO;
+      cmdbuf[3] = buf[1];
+      cmdbuf[4] = buf[1];
+      break;
+    default:
+      return 0;
+    }
+
+  if (regno == HARD_PSW_REGNUM)
+    rc += bdm12_put_packet (cmdbuf, 5);
+  else
+    rc += bdm12_put_packet (cmdbuf, 3);
+
+  if (rc)
+    return 0;
+
+  return length;
+}
+
+/* Write memory to the target. */
+
+int
+bdm12_write (CORE_ADDR memaddr, unsigned char *buf, int len)
+{
+  unsigned char *cmdbuf;
+  unsigned int numwritten = 0;
+  int need_final_write = 0;
+
+  /* allow writes to flash and eeprom if the program isn't loaded yet */
+  if (!program_loaded && !valid_write_range (memaddr, memaddr + len - 1))
+    {
+      if (!valid_read_range (memaddr, memaddr + len - 1) || len <= 0)
+        return 0;
+      if (memaddr >= eeprom_base &&
+          memaddr < (eeprom_base + BDM12_SIZE_EEPROM) &&
+          (memaddr + len - 1) >= eeprom_base &&
+          (memaddr + len - 1) < (eeprom_base + BDM12_SIZE_EEPROM))
+        return bdm12_eeprom_write (memaddr, buf, len);
+      else if (memaddr >= flash_base &&
+            memaddr < (flash_base + BDM12_SIZE_FLASH) &&
+            (memaddr + len - 1) >= flash_base &&
+            (memaddr + len - 1) < (flash_base + BDM12_SIZE_FLASH))
+        return bdm12_flash_write (memaddr, buf, len);
+      else
+        {
+          error ("writing between different regions of memory");
+          return 0;
+        }
+    }
+  else if (!valid_write_range (memaddr, memaddr + len - 1) || len <= 0)
+    return 0;
+
+  cmdbuf = alloca (len + 6);
+  if (!cmdbuf)
+    return 0;
+
+  if (memaddr & 0x1)
+    {
+      cmdbuf[0] = BDM12_CMD_WRITE_BYTE;
+      cmdbuf[1] = memaddr >> 8;
+      cmdbuf[2] = memaddr;
+      cmdbuf[3] = *buf;
+      cmdbuf[4] = cmdbuf[3];
+      if (bdm12_put_packet (cmdbuf, 5))
+        return numwritten;
+      len--;
+      buf++;
+      numwritten++;
+      memaddr++;
+    }
+
+  if (len & 0x1)
+    {
+      need_final_write = 1;
+      len--;
+    }
+#if 0 /* MEMPUT command seems to cause communications hangups easily */
+    if (len)
+    {
+      cmdbuf[0] = BDM12_CMD_EXT;
+      cmdbuf[1] = BDM12_CMD_EXT_MEMPUT;
+      cmdbuf[2] = memaddr >> 8;
+      cmdbuf[3] = memaddr ;
+      cmdbuf[4] = (len / 2) >> 8;
+      cmdbuf[5] = (len / 2);
+      memcpy (cmdbuf + 6, buf, len);
+      if (bdm12_put_packet (cmdbuf, len + 6))
+        return numwritten;
+      buf += len;
+      numwritten += len;
+      memaddr += len;
+    }
+#endif
+
+#if 1
+
+  cmdbuf[0] = BDM12_CMD_WRITE_WORD;
+  while (len)
+    {
+      cmdbuf[1] = memaddr >> 8;
+      cmdbuf[2] = memaddr;
+      cmdbuf[3] = *(buf++);
+      cmdbuf[4] = *(buf++);
+      if (bdm12_put_packet (cmdbuf, 5))
+        return numwritten;
+      memaddr += 2;
+      numwritten += 2;
+      len -= 2;
+    }
+
+#endif
+
+  if (need_final_write)
+    {
+      cmdbuf[0] = BDM12_CMD_WRITE_BYTE;
+      cmdbuf[1] = memaddr >> 8;
+      cmdbuf[2] = memaddr;
+      cmdbuf[3] = *buf;
+      cmdbuf[4] = cmdbuf[3];
+      if (bdm12_put_packet (cmdbuf, 5))
+        return numwritten;
+      numwritten++;
+    }
+
+  return numwritten;
+}
+
+static int
+bdm12_eeprom_write (CORE_ADDR memaddr, char *buf, int len)
+{
+  unsigned char cmdbuf[6], recvbuf[2];
+  int numwritten = 0, need_final_write = 0;
+
+  if (memaddr & 0x1)
+    {
+      cmdbuf[0] = BDM12_CMD_READ_BYTE;
+      cmdbuf[1] = (memaddr - 1) >> 8;
+      cmdbuf[2] = (memaddr - 1);
+      if (bdm12_put_packet (cmdbuf, 3))
+        return numwritten;
+      if (bdm12_get_packet (recvbuf, 2))
+        return numwritten;
+      cmdbuf[0] = BDM12_CMD_EEPROM_WRITE;
+      cmdbuf[3] = recvbuf[0];
+      cmdbuf[4] = *buf;
+      if (bdm12_put_packet (cmdbuf, 5))
+        return numwritten;
+      len--;
+      buf++;
+      numwritten++;
+      memaddr++;
+    }
+
+  if (len & 0x1)
+    {
+      need_final_write = 1;
+      len--;
+    }
+
+  while (len)
+    {
+      cmdbuf[1] = memaddr >> 8;
+      cmdbuf[2] = memaddr;
+      cmdbuf[3] = *(buf++);
+      cmdbuf[4] = *(buf++);
+      if (bdm12_put_packet (cmdbuf, 5))
+        return numwritten;
+      memaddr += 2;
+      numwritten += 2;
+      len -= 2;
+    }
+
+  if (need_final_write)
+    {
+      cmdbuf[0] = BDM12_CMD_READ_BYTE;
+      cmdbuf[1] = (memaddr + 1) >> 8;
+      cmdbuf[2] = (memaddr + 1);
+      if (bdm12_put_packet (cmdbuf, 3))
+        return numwritten;
+      if (bdm12_get_packet (recvbuf, 2))
+        return numwritten;
+      cmdbuf[0] = BDM12_CMD_EEPROM_WRITE;
+      cmdbuf[3] = *buf;
+      cmdbuf[4] = recvbuf[1];
+      if (bdm12_put_packet (cmdbuf, 5))
+        return numwritten;
+      numwritten++;
+    }
+  return numwritten;
+}
+
+static int
+bdm12_flash_write (CORE_ADDR memaddr, char *buf, int len)
+{
+  unsigned char cmdbuf[2];
+  int numwritten = 0, dum, expectedsize, actualsize;
+  int packetsize = BDM12_SIZE_RAM - BDM12_PROGRAMFLASH_SIZE;
+
+  struct timeval start_time, cur_time;
+  enum bdm12_stop reason;
+
+  if (!flash_erased)
+    {
+      /* check to see if what is going to be written is the same as
+         what is already in flash, so that we don't write to flash
+         needlessly */
+      cur_region->next = xmalloc (sizeof (struct memory_region_list));
+      if (!cur_region->next)
+        return numwritten;
+      cur_region->data = xmalloc (len);
+      if (!cur_region->data)
+        {
+          xfree (cur_region->next);
+          cur_region->next = NULL;
+          return numwritten;
+        }
+      if (bdm12_read (memaddr, cur_region->data, len) != len)
+        {
+          xfree (cur_region->next);
+          xfree (cur_region->data);
+          cur_region->next = NULL;
+          cur_region->data = NULL;
+          return numwritten;
+        }
+      if (memcmp (cur_region->data, buf, len) == 0)
+        {
+          cur_region->size = len;
+          cur_region->addr = memaddr;
+          cur_region->next->prev = cur_region;
+          cur_region->next->next = NULL;
+          cur_region->next->size = 0;
+          cur_region->next->data = NULL;
+          cur_region = cur_region->next;
+          return len;
+        }
+
+      xfree(cur_region->next);
+      cur_region->next = NULL;
+
+      /* erase the flash array */
+      if (erase_flash ())
+        {
+          error ("Unable to erase flash");
+          return numwritten;
+        }
+      flash_erased = 1;
+      /* write the flash burning program into RAM - the program is in
+         bdm12_programflash.h */
+      if (bdm12_write (ram_base, programflash, BDM12_PROGRAMFLASH_SIZE) !=
+          BDM12_PROGRAMFLASH_SIZE)
+        return numwritten;
+      /* tell the burn program where the registers are */
+      cmdbuf[0] = reg_base >> 8;
+      cmdbuf[1] = reg_base;
+      if (bdm12_write (ram_base + BDM12_PROGRAMFLASH_REGSTART, cmdbuf, 2) != 2)
+        return numwritten;
+      /* tell the burn program where the data starts */
+      cmdbuf[0] = (ram_base + BDM12_PROGRAMFLASH_SIZE) >> 8;
+      cmdbuf[1] = (ram_base + BDM12_PROGRAMFLASH_SIZE);
+      if (bdm12_write (ram_base + BDM12_PROGRAMFLASH_DATASTART, cmdbuf, 2) != 2)
+        return numwritten;
+
+      /* now write all the previously stored regions */
+      for (cur_region = &flash_regions; cur_region->next != NULL;
+           cur_region = cur_region->next)
+        {
+          if (bdm12_flash_write (cur_region->addr, cur_region->data,
+              cur_region->size) != cur_region->size)
+            return numwritten;
+        }
+    }
+
+  /* tell the burn program where flash is */
+  while (len > 0)
+    {
+      if (len < packetsize)
+          expectedsize = len;
+      else
+          expectedsize = packetsize;
+
+      /* write the next packet in target RAM */
+      if (bdm12_write (ram_base + BDM12_PROGRAMFLASH_SIZE, buf,
+          expectedsize) != expectedsize)
+        break;
+
+      /* tell the burn program the starting flash address */
+      cmdbuf[0] = memaddr >> 8;
+      cmdbuf[1] = memaddr;
+      if (bdm12_write (ram_base + BDM12_PROGRAMFLASH_FLASHSTART, cmdbuf, 2) != 2)
+        break;
+      
+      /* tell the burn program the ending flash address (noninclusive) */
+      cmdbuf[0] = (memaddr + expectedsize) >> 8;
+      cmdbuf[1] = (memaddr + expectedsize);
+      if (bdm12_write (ram_base + BDM12_PROGRAMFLASH_FLASHEND, cmdbuf, 2) != 2)
+        break;
+
+      /* set the PC */
+      cmdbuf[0] = (ram_base + BDM12_PROGRAMFLASH_PROGSTART) >> 8;
+      cmdbuf[1] = (ram_base + BDM12_PROGRAMFLASH_PROGSTART);
+      if (bdm12_store_register (HARD_PC_REGNUM, cmdbuf, 2) != 2)
+        break;
+    
+      /* run the burn program */
+      if (bdm12_resume (0))
+        break;
+
+      /* wait for burn program t finish; it should go back into bdm mode */
+      gettimeofday (&start_time, NULL);
+      do
+        { 
+          bdm12_stop_reason (&reason, &dum);
+          gettimeofday (&cur_time, NULL);
+          if (diffms (start_time, cur_time) > BDM12_PROGRAMFLASH_TIMEOUT *
+              expectedsize)
+            {
+              bdm12_stop_reason (&reason, &dum);
+              if (reason == BDM12_RUNNING)
+                break;
+            }
+        } while (reason == BDM12_RUNNING);
+      /* check error flag */
+      if (bdm12_read (ram_base + BDM12_PROGRAMFLASH_NUMWRITTEN, cmdbuf, 2) != 2)
+        break;
+
+      actualsize = (cmdbuf[0] << 8) + cmdbuf[1];
+      numwritten += actualsize;
+      if (expectedsize != actualsize)
+        break;
+      memaddr += actualsize;
+      buf += actualsize;
+      len -= actualsize;
+    }
+  return numwritten;
+}
+
+static int
+erase_flash(void)
+{
+  unsigned char buf[2];
+  struct timeval start_time, cur_time;
+  int dum;
+  enum bdm12_stop reason;
+
+  /* write the erase program into RAM - the program is in bdm12_eraseflash.h */
+  if (bdm12_write (ram_base, eraseflash, BDM12_ERASEFLASH_SIZE) !=
+      BDM12_ERASEFLASH_SIZE)
+    return 1;
+
+  /* tell the erase program where flash is */
+  buf[0] = flash_base >> 8;
+  buf[1] = flash_base;
+  if (bdm12_write (ram_base + BDM12_ERASEFLASH_FLASHSTART, buf, 2) != 2)
+    return 1;
+
+  /* tell the erase program where the registers are */
+  buf[0] = reg_base >> 8;
+  buf[1] = reg_base;
+  if (bdm12_write (ram_base + BDM12_ERASEFLASH_REGSTART, buf, 2) != 2)
+    return 1;
+
+  /* set the PC */
+  buf[0] = (ram_base + BDM12_ERASEFLASH_PROGSTART) >> 8;
+  buf[1] = (ram_base + BDM12_ERASEFLASH_PROGSTART);
+  if (bdm12_store_register (HARD_PC_REGNUM, buf, 2) != 2)
+    return 1;
+
+  /* run the erase program */
+  if (bdm12_resume (0))
+    return 1;
+  /* wait for erase program to finish; it should go back into bdm mode */
+  
+  gettimeofday (&start_time, NULL);
+  do
+    { 
+      bdm12_stop_reason (&reason, &dum);
+      gettimeofday (&cur_time, NULL);
+      if (diffms (start_time, cur_time) > BDM12_ERASEFLASH_TIMEOUT)
+        {
+          bdm12_stop_reason (&reason, &dum);
+          if (reason == BDM12_RUNNING)
+            return 1;
+        }
+    } while (reason == BDM12_RUNNING);
+
+  /* check error flag */
+  if (bdm12_read (ram_base + BDM12_ERASEFLASH_ERRORFLAG, buf, 1) != 1)
+    return 1;
+
+  return buf[0];
+}
+
+void
+bdm12_stop_reason (enum bdm12_stop *reason, int *sigrc)
+{
+  unsigned char buf[3];
+
+  buf[0] = BDM12_CMD_READ_BD_BYTE;
+  buf[1] = BDM12_BDM_HI;
+  buf[2] = BDM12_ENABLE_BDM_LO;
+  if (bdm12_put_packet (buf, 3))
+    {
+      *reason = BDM12_POLLING;
+      return;
+    }
+  if (bdm12_get_packet (buf, 2))
+    {
+      *reason = BDM12_POLLING;
+      return;
+    }
+
+  if (!(buf[1] & BDM12_STATUS_STOPPED))
+    {
+      *reason = BDM12_RUNNING;
+      return;
+    }
+  if (num_breakpoints > 0)
+    {
+      unsigned char pcbuf[2];
+      CORE_ADDR pc;
+      if (bdm12_fetch_register (HARD_PC_REGNUM, pcbuf, 2) != 2)
+        {
+          *reason = BDM12_POLLING;
+          return;
+        }
+      pc = (pcbuf[0] << 8) + pcbuf[1];
+      if (pc == breakpoint[0])
+        {
+          *reason = BDM12_STOPPED;
+          *sigrc = TARGET_SIGNAL_TRAP;
+          return;
+        }
+      if ((num_breakpoints == 2) && (pc == breakpoint[1]))
+        {
+          *reason = BDM12_STOPPED;
+          *sigrc = TARGET_SIGNAL_TRAP;
+          return;
+        }
+    }
+
+  if (stopped)
+    {
+      *reason = BDM12_STOPPED;
+      *sigrc = TARGET_SIGNAL_INT;
+      return;
+    }
+  if (singlestepped)
+    {
+      *reason = BDM12_STOPPED;
+      *sigrc = TARGET_SIGNAL_TRAP;
+      return;
+    }
+
+  /* don't know why we stopped */
+  *reason = BDM12_POLLING;
+  return;
+}
+
+static int
+valid_write_range (CORE_ADDR start_addr, CORE_ADDR end_addr)
+{
+  if (((start_addr >= reg_base && start_addr < (reg_base + BDM12_SIZE_REG)) &&
+       (end_addr >= reg_base && end_addr < (reg_base + BDM12_SIZE_RAM))) ||
+      ((start_addr >= ram_base && start_addr < (ram_base + BDM12_SIZE_RAM)) &&
+       (end_addr >= ram_base && end_addr < (ram_base + BDM12_SIZE_RAM))))
+    return 1;
+
+  return 0;
+}
+
+/* Read memory from the target. */
+
+int
+bdm12_read (CORE_ADDR memaddr, unsigned char *buf, int len)
+{
+  unsigned char cmdbuf[6], *recvbuf;
+  unsigned int numread = 0;
+  int need_final_read = 0;
+
+  if (!valid_read_range (memaddr, memaddr + len - 1) || len < 0)
+    return 0;
+
+  if (len == 0)
+    return 0;
+
+  recvbuf = alloca (len);
+  if (!recvbuf)
+    return 0;
+
+  if (memaddr & 0x1)
+    {
+      cmdbuf[0] = BDM12_CMD_READ_BYTE;
+      cmdbuf[1] = memaddr >> 8;
+      cmdbuf[2] = memaddr;
+      if (bdm12_put_packet (cmdbuf, 3))
+        return numread;
+      if (bdm12_get_packet (recvbuf, 2))
+        return numread;
+      *(buf++) = recvbuf[1];
+      len--;
+      numread++;
+      memaddr++;
+    }
+
+  if (len & 0x1)
+    {
+      need_final_read = 1;
+      len--;
+    }
+
+  if (len)
+    {
+      cmdbuf[0] = BDM12_CMD_EXT;
+      cmdbuf[1] = BDM12_CMD_EXT_MEMDUMP;
+      cmdbuf[2] = memaddr >> 8;
+      cmdbuf[3] = memaddr ;
+      cmdbuf[4] = (len / 2) >> 8;
+      cmdbuf[5] = (len / 2);
+      if (bdm12_put_packet (cmdbuf, 6))
+        return numread;
+      if (bdm12_get_packet (recvbuf, len))
+        return numread;
+      memcpy (buf, recvbuf, len);
+      buf += len;
+      numread += len;
+      memaddr += len;
+    }
+
+  if (need_final_read)
+    {
+      cmdbuf[0] = BDM12_CMD_READ_BYTE;
+      cmdbuf[1] = memaddr >> 8;
+      cmdbuf[2] = memaddr;
+      if (bdm12_put_packet (cmdbuf, 3))
+        return numread;
+      if (bdm12_get_packet (recvbuf, 2))
+        return numread;
+      *(buf++) = recvbuf[0];
+      numread++;
+    }
+
+  return numread;
+}
+
+static int
+valid_read_range (CORE_ADDR start_addr, CORE_ADDR end_addr)
+{
+  if (((start_addr >= reg_base && start_addr < (reg_base + BDM12_SIZE_REG)) &&
+       (end_addr >= reg_base && end_addr < (reg_base + BDM12_SIZE_REG))) ||
+      ((start_addr >= ram_base && start_addr < (ram_base + BDM12_SIZE_RAM)) &&
+       (end_addr >= ram_base && end_addr < (ram_base + BDM12_SIZE_RAM))) ||
+      ((start_addr >= eeprom_base && start_addr < (eeprom_base + BDM12_SIZE_EEPROM)) &&
+       (end_addr >= eeprom_base && end_addr < (eeprom_base + BDM12_SIZE_EEPROM))) ||
+      ((start_addr >= flash_base && start_addr < (flash_base + BDM12_SIZE_FLASH)) &&
+       (end_addr >= flash_base && end_addr < (flash_base + BDM12_SIZE_FLASH))))
+    return 1;
+
+  return 0;
+}
+
+/* Send a packet to the BDM12 pod. This is basically copied from Kevin's
+   BDM12 User Manual */
+
+static int
+bdm12_put_packet (unsigned char *packet, int len)
+{
+  int i, iloop;
+  struct timeval start_time, cur_time;
+
+  for (i = 0; i < len; i++)
+    {
+      write_rts_state (1);
+
+      iloop = 5;
+      gettimeofday (&start_time, NULL);
+      cur_time = start_time;
+      while ((diffms (start_time, cur_time) < BDM12_COMM_TIMEOUT) || iloop)
+        {
+          if (read_cts_state ())
+            break;
+
+          write_rts_state (0);
+          gettimeofday (&cur_time, NULL);
+          if (iloop)
+            --iloop;
+
+          write_rts_state (1);
+        }
+      if (!read_cts_state ())
+        {
+          error ("bdm12_put_packet RTS1->CTS1: Couldn't communicate with BDM12 pod");
+          return 1;
+        }
+
+      if (serial_write (ser_desc, packet, 1))
+        {
+          write_rts_state (0);
+          perror_with_name ("bdm12_put_packet");
+          return 1;
+        }
+
+      iloop = 5;
+      gettimeofday (&start_time, NULL);
+      cur_time = start_time;
+      while ((diffms (start_time, cur_time) < BDM12_COMM_TIMEOUT) || iloop)
+        {
+          if (!read_cts_state ())
+            break;
+
+          gettimeofday (&cur_time, NULL);
+          if (iloop)
+            --iloop;
+
+        }
+      write_rts_state (0);
+      if (read_cts_state ())
+        {
+          error ("bdm12_put_packet RTS0->CTS0: Couldn't communicate with BDM12 pod");
+          return 1;
+        }
+      packet++;
+    }
+  return 0;
+}
+
+/* Raise or lower the RTS line (clear if state==0, set otherwise). This is
+   also based on code from Kevin's BDM12 User's Manual. */
+
+static void 
+write_rts_state (int state)
+{
+  
+#if defined(__CYGWIN32__) || defined(__MINGW32__)
+  EscapeCommFunction (win_ser_desc, state ? SETRTS : CLRRTS);
+#else
+  struct timeval start_time, cur_time;
+
+  int tiocm = TIOCM_RTS;
+  ioctl (ser_desc->fd, state ? TIOCMBIS : TIOCMBIC, &tiocm);
+  
+  gettimeofday (&start_time, NULL);
+  cur_time = start_time;
+  while ((diffms (start_time, cur_time) < BDM12_RTS_DELAY))
+    {
+      gettimeofday (&cur_time, NULL);
+    }
+#endif
+}
+
+/* Return the state of the CTS line (0 if clear, 1 if set). This is also
+   based on code from Kevin's BDM12 User's Manual. */
+
+static int
+read_cts_state (void)
+{
+#if defined(__CYGWIN32__) || defined(__MINGW32__)
+  DWORD cts_state;
+  GetCommModemStatus (win_ser_desc, &cts_state);
+  return (cts_state & MS_CTS_ON) ? 1 : 0;
+#else
+  /* assuming UNIX - if not, add your own #elseif above */
+  unsigned int cts_state;
+  ioctl (ser_desc->fd, TIOCMGET, &cts_state);
+  return (cts_state & TIOCM_CTS) ? 1 : 0;
+#endif
+}
+
+/* take the difference of t2 - t1 in milliseconds */
+
+static long
+diffms (struct timeval t1, struct timeval t2)
+{
+  long diffsec, diffusec;
+
+  diffsec = t2.tv_sec - t1.tv_sec;
+  diffusec = t2.tv_usec - t1.tv_usec;
+
+  if (diffusec < 0)
+    {
+      diffsec--;
+      diffusec += 1000000;
+    }
+
+  return (diffsec * 1000) + (diffusec / 1000);
+}
+
+/* Get a packet from the BDM12.  Timeout is only enforced for the
+   first byte of the packet.  Subsequent bytes are expected to arrive in
+   time <= remote_timeout.  Returns a pointer to a static buffer containing
+   the payload of the packet.  *LENP contains the length of the packet.
+ */
+
+static int bdm12_get_packet (unsigned char *packet, int pktlen)
+{
+  int i, ch;
+
+  for (i = 0; i < pktlen; i++)
+    {
+      ch = serial_readchar (ser_desc, BDM12_COMM_TIMEOUT);
+      switch (ch)
+        {
+        case SERIAL_EOF:
+          error ("Remote connection closed");
+          return 1;
+          break;
+        case SERIAL_ERROR:
+          perror_with_name ("bdm12_get_packet");
+          return 1;
+          break;
+        case SERIAL_TIMEOUT:
+          error ("Remote connection timed out");
+          return 1;
+          break;
+        default:
+          *(packet++) = ch;
+          break;
+        }
+    }
+  return 0;
+}
+
+/* All we actually do is set the PC to the start address of exec_bfd, and start
+   the program at that point.  */
+
+/* load a program into target memory, the bfd struct is not used here */
+
+BDM12_RC
+bdm12_load (char *prog, struct _bfd *abfd, int from_tty)
+{
+  generic_load (prog, from_tty);
+
+  program_loaded = 1;
+/* This is necessary because many things were based on the PC at the time that
+   we attached to the monitor, which is no longer valid now that we have loaded
+   new code (and just changed the PC).  Another way to do this might be to call
+   normal_stop, except that the stack may not be valid, and things would get
+   horribly confused... */
+
+  clear_symtab_users ();
+  return BDM12_RC_OK;
+}
+
+BDM12_RC
+bdm12_set_breakpoint (CORE_ADDR addr)
+{
+  unsigned char buf[5];
+
+  if (num_breakpoints >= BDM12_MAX_BREAKPOINTS)
+    {
+      error ("Maximum breakpoints have already been set");
+      return BDM12_RC_INSUFFICIENT_RESOURCES;
+    }
+
+  if (num_breakpoints == 0)
+    buf[2] = BDM12_REG_BRKAH;
+  else
+    buf[2] = BDM12_REG_BRKDH;
+
+  buf[0] = BDM12_CMD_WRITE_WORD;
+  buf[1] = reg_page;
+  buf[3] = addr >> 8;
+  buf[4] = addr;
+  if (bdm12_put_packet (buf, 5))
+    return BDM12_RC_FAIL;
+  breakpoint[num_breakpoints] = addr;
+  num_breakpoints++;
+  return BDM12_RC_OK;
+}
+
+BDM12_RC
+bdm12_clear_breakpoint (CORE_ADDR addr)
+{
+  unsigned char buf[5];
+  if (breakpoint[0] == addr)
+    {
+      buf[2] = BDM12_REG_BRKAH;
+      breakpoint[0] = 0;
+    }
+  else if (breakpoint[1] == addr)
+    {
+      buf[2] = BDM12_REG_BRKDH;
+      breakpoint[1] = 0;
+    }
+  else
+    {
+       error ("breakpoint doesn't exist");
+       return BDM12_RC_UNKNOWN_BREAKPOINT;
+    }
+
+  buf[0] = BDM12_CMD_WRITE_WORD;
+  buf[1] = reg_page;
+  buf[3] = 0;
+  buf[4] = 0;
+  if (bdm12_put_packet (buf, 5))
+    return BDM12_RC_FAIL;
+
+  num_breakpoints--;
+  return BDM12_RC_OK;
+}
+
+
+void
+_initialize_bdm12 (void)
+{
+  flash_regions.next = NULL;
+  flash_regions.prev = NULL;
+  flash_regions.data = NULL;
+  flash_regions.size = 0;
+}
+
+#if 0
+/* maybe I should do something like this - later*/
+void _initialize_remote_ocd (void)
+{
+  extern struct cmd_list_element *cmdlist;
+  static struct cmd_list_element *ocd_cmd_list = NULL;
+
+  add_show_from_set (add_set_cmd ("remotetimeout", no_class,
+                                  var_integer, (char *) &remote_timeout,
+                     "Set timeout value for remote read.\n", &setlist),
+                     &showlist);
+
+  add_prefix_cmd ("ocd", class_obscure, bdm_command, "", &ocd_cmd_list, "ocd ",
+                   0, &cmdlist);
+
+  add_cmd ("reset", class_obscure, bdm_reset_command, "", &ocd_cmd_list);
+  add_cmd ("restart", class_obscure, bdm_restart_command, "", &ocd_cmd_list);
+  add_cmd ("update-flash", class_obscure, bdm_update_flash_command, "", &ocd_cmd_list);
+}
+#endif
+
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/bdm12.h gdb-6.4-m68hc1x/gdb/bdm12.h
--- gdb-6.4/gdb/bdm12.h	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/bdm12.h	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,289 @@
+/* This file defines the interface between the BDM12 target and gdb.
+   Copyright (C) 2001, 2004 Free Software Foundation, Inc.
+   Contributed by Tim Housel (thousel@usa.net)
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+/* This is basically  */
+#if !defined (BDM12_H)
+#define BDM12_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef REGISTER_BDM12_REGNO
+#define REGISTER_BDM12_REGNO(N) (N)
+#endif
+
+/* Return codes from various functions.  */
+
+typedef enum {
+  BDM12_RC_FAIL = 0,
+  BDM12_RC_OK = 1,
+  BDM12_RC_UNKNOWN_BREAKPOINT = 2,
+  BDM12_RC_INSUFFICIENT_RESOURCES = 3,
+  BDM12_RC_DUPLICATE_BREAKPOINT = 4
+} BDM12_RC;
+
+/* these defines were pulled from Stephane's code in
+   m68hc11-tdep.c */  
+
+#define HARD_X_REGNUM        0
+#define HARD_D_REGNUM        1
+#define HARD_Y_REGNUM        2
+#define HARD_SP_REGNUM       3
+#define HARD_PC_REGNUM       4
+#define HARD_A_REGNUM        5
+#define HARD_B_REGNUM        6
+#define HARD_PSW_REGNUM      7
+
+/* commands for the BDM12 pod */
+
+typedef enum {
+  BDM12_CMD_SYNC = 0x0,
+  BDM12_CMD_RESET = 0x1,
+  BDM12_CMD_EXT = 0x4,
+  BDM12_CMD_EXT_MEMDUMP = 0x3,
+  BDM12_CMD_EXT_SETPARAM = 0x4,
+  BDM12_CMD_EXT_MEMPUT = 0x6,
+  BDM12_CMD_EEPROM_WRITE = 0x5,
+  BDM12_CMD_SET_REGBASE = 0x6,
+  BDM12_CMD_EEPROM_ERASE = 0x7,
+  BDM12_CMD_BACKGROUND = 0x90,
+  BDM12_CMD_READ_BD_BYTE = 0xe4,
+  BDM12_CMD_READ_BD_WORD = 0xec,
+  BDM12_CMD_READ_WORD = 0xe8,
+  BDM12_CMD_READ_BYTE = 0xe0,
+  BDM12_CMD_WRITE_BD_BYTE = 0xc4,
+  BDM12_CMD_WRITE_BD_WORD = 0xcc,
+  BDM12_CMD_WRITE_WORD = 0xc8,
+  BDM12_CMD_WRITE_BYTE = 0xc0,
+  BDM12_CMD_READ_NEXT = 0x62,
+  BDM12_CMD_READ_PC = 0x63,
+  BDM12_CMD_READ_D = 0x64,
+  BDM12_CMD_READ_X = 0x65,
+  BDM12_CMD_READ_Y = 0x66,
+  BDM12_CMD_READ_SP = 0x67,
+  BDM12_CMD_WRITE_NEXT = 0x42,
+  BDM12_CMD_WRITE_PC = 0x43,
+  BDM12_CMD_WRITE_D = 0x44,
+  BDM12_CMD_WRITE_X = 0x45,
+  BDM12_CMD_WRITE_Y = 0x46,
+  BDM12_CMD_WRITE_SP = 0x47,
+  BDM12_CMD_GO = 0x8,
+  BDM12_CMD_TRACE1 = 0x10,
+  BDM12_CMD_TAGGO = 0x18
+} BDM12_CMD;  
+
+/* e-clock rates as required by the BDM12 pod */
+
+typedef enum {
+  BDM12_ECLOCK_1MHZ = 0x0,
+  BDM12_ECLOCK_2MHZ = 0x1,
+  BDM12_ECLOCK_4MHZ = 0x2,
+  BDM12_ECLOCK_8MHZ = 0x3
+} BDM12_ECLOCK;
+
+/* misc stuff used to avoid magic constants */
+
+typedef enum {
+  BDM12_BDM_HI = 0xff,
+  BDM12_ENABLE_BDM_LO = 0x01,
+  BDM12_CCRSAV_BDM_LO = 0x06,
+  BDM12_REG_INITRG = 0x11,
+  BDM12_REG_INITRM = 0x10,
+  BDM12_REG_INITEE = 0x12,
+  BDM12_REG_MISC = 0x13,
+  BDM12_REG_BRKCT0 = 0x20,
+  BDM12_REG_BRKCT1 = 0x21,
+  BDM12_REG_BRKAH = 0x22,
+  BDM12_REG_BRKAL = 0x23,
+  BDM12_REG_BRKDH = 0x24,
+  BDM12_REG_BRKDL = 0x25,
+  BDM12_REG_FEEMCR = 0xf5,
+  BDM12_SIZE_REG = 512,
+  BDM12_SIZE_RAM = 1024,
+  BDM12_SIZE_EEPROM = 768,
+  BDM12_SIZE_FLASH = 32768,
+  BDM12_INIT_ENABLE_BDM = 0x80,
+  BDM12_INIT_BRKCT0 = 0xec,
+  BDM12_INIT_BRKCT1 = 0x40,
+  BDM12_INIT_FEEMCR = 0x0,
+  BDM12_STATUS_STOPPED = 0x40,
+  BDM12_MAX_BREAKPOINTS = 2,
+  BDM12_BAUD_RATE = 115200,
+  BDM12_COMM_TIMEOUT = 1, /* 1s timeout for serial ops */
+  BDM12_ERASEFLASH_TIMEOUT = 1000, /* 200 ms timeout for flash erase program */
+  BDM12_PROGRAMFLASH_TIMEOUT = 3 /* 3 ms/byte  timeout for flash burn program */
+} BDM12_MISC;
+  
+/* The bfd struct, as an opaque type.  */
+
+struct _bfd;
+
+
+/* Main bdm12 entry points.  */
+
+
+/* Create a fully initialized bdm12 instance.
+
+   (This function is called when the bdm12 target is selected from the
+   gdb command line.)
+
+   ARGV is a standard ARGV pointer such as that passed from the
+   command line.  The syntax of the argument list is is assumed to be
+   ``BDM12 { BDM12-OPTION }''.
+
+   While the bdm12 configuration can be parameterized by (in decreasing
+   precedence) ARGV's BDM12-OPTION and the ABFD argument, the
+   successful creation of the bdm12 target shall not be dependent on the
+   presence of any of these arguments/options. */
+
+
+extern BDM12_RC bdm12_open (char **argv);
+
+
+/* Destory a bdm12 instance.
+
+   QUITTING is non-zero if we cannot hang on errors.
+*/
+
+extern void bdm12_close (int quitting);
+
+
+/* Load program PROG into the target memory.
+
+   If ABFD is non-NULL, the bfd for the file has already been opened.
+   The result is a return code indicating success. */
+
+extern BDM12_RC bdm12_load (char *prog, struct _bfd *abfd, int from_tty);
+
+
+/* Prepare to run the program.
+
+   ABFD, if not NULL, provides initial processor state information.
+   ARGV and ENV, if non NULL, are NULL terminated lists of pointers.
+
+   This function shall initialize the processor
+   registers to a known value.  The program counter and possibly stack
+   pointer shall be set using information obtained from ABFD (or
+   hardware reset defaults).  ARGV and ENV, dependant on the target
+   ABI, may be written to memory. */
+
+extern BDM12_RC bdm12_create_inferior (bfd *abfd, char **argv, char **env);
+
+
+/* Fetch LENGTH bytes of the target's memory.  Start fetch
+   at virtual address MEM and store in BUF.  Result is number of bytes
+   read, or zero if error.  */
+
+extern int bdm12_read (CORE_ADDR mem, unsigned char *buf, int length);
+
+
+/* Store LENGTH bytes from BUF into the target's
+   memory. Store bytes starting at virtual address MEM. Result is
+   number of bytes write, or zero if error.  */
+
+extern int bdm12_write (CORE_ADDR mem, unsigned char *buf, int length);
+
+
+/* Fetch register REGNO storing its raw (target endian) value in the
+   LENGTH byte buffer BUF.  Return the actual size of the register or
+   zero if REGNO is not applicable.
+
+   Legacy implementations ignore LENGTH and always return -1.
+
+   If LENGTH does not match the size of REGNO no data is transfered
+   (the actual register size is still returned). */
+
+extern int bdm12_fetch_register (int regno, unsigned char *buf, int length);
+
+
+/* Store register REGNO from the raw (target endian) value in BUF.
+   Return the actual size of the register or zero if REGNO is not
+   applicable.
+
+   Legacy implementations ignore LENGTH and always return -1.
+
+   If LENGTH does not match the size of REGNO no data is transfered
+   (the actual register size is still returned). */
+
+extern int bdm12_store_register (int regno, unsigned char *buf, int length);
+
+
+/* Run (or resume) the program.
+
+   STEP, when non-zero indicates that only a single instruction
+   should be executed. */
+
+extern int bdm12_resume (int step);
+
+
+/* Asynchronous request to stop execution.
+   A nonzero return indicates that the target is able to handle
+   the request */
+
+extern int bdm12_stop (void);
+
+
+/* Fetch the REASON why the program stopped.
+
+   BDM12_EXITED: The program has terminated. SIGRC indicates the target
+   dependant exit status.
+
+   BDM12_STOPPED: The program has stopped.  SIGRC uses the host's signal
+   numbering as a way of identifying the reaon: program interrupted by
+   user via a bdm12_stop request (SIGINT); a breakpoint instruction
+   (SIGTRAP); a completed single step (SIGTRAP); an internal error
+   condition (SIGABRT); an illegal instruction (SIGILL); Access to an
+   undefined memory region (SIGSEGV); Mis-aligned memory access
+   (SIGBUS).  For some signals information in addition to the signal
+   number may be retained by the target (e.g. offending address);
+   that information is not directly accessable via this interface.
+
+   BDM12_SIGNALLED: The program has been terminated by a signal. The
+   target has encountered code that causes the the program
+   to exit with signal SIGRC.
+
+   BDM12_RUNNING, BDM12_POLLING: The return of one of these values
+   indicates a problem internal to the BDM12 interface. */
+
+enum bdm12_stop { BDM12_RUNNING, BDM12_POLLING, BDM12_EXITED, BDM12_STOPPED, BDM12_SIGNALLED };
+
+extern void bdm12_stop_reason (enum bdm12_stop *reason, int *sigrc);
+
+#if 0
+/* implement later */
+/* Passthru for other commands that the bdm12 interface might support.
+   The interface should be prepared to deal with any combination of NULL
+   or empty CMD. */
+
+void bdm12_do_command PARAMS ((char *cmd));
+
+#endif
+
+/* Call these functions to set and clear breakpoints at ADDR. */
+
+extern BDM12_RC bdm12_set_breakpoint (CORE_ADDR addr);
+extern BDM12_RC bdm12_clear_breakpoint (CORE_ADDR addr);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* !defined (BDM12_H) */
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/bdm12_eraseflash.h gdb-6.4-m68hc1x/gdb/bdm12_eraseflash.h
--- gdb-6.4/gdb/bdm12_eraseflash.h	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/bdm12_eraseflash.h	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,249 @@
+#define BDM12_ERASEFLASH_SIZE 208
+#define BDM12_ERASEFLASH_FLASHSTART 0
+#define BDM12_ERASEFLASH_REGSTART 2
+#define BDM12_ERASEFLASH_ERRORFLAG 9
+#define BDM12_ERASEFLASH_PROGSTART 10
+
+unsigned char eraseflash[BDM12_ERASEFLASH_SIZE] = {
+ 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
+ 0x00, 0x01, 0x1B, 0xD4, 0x14, 0x10, 0xEE, 0xF2, 
+ 0x00, 0x00, 0x69, 0xF2, 0x00, 0x06, 0x69, 0xF2, 
+ 0x00, 0x07, 0x69, 0xF2, 0x00, 0x08, 0xED, 0xF2, 
+ 0x00, 0x02, 0x0F, 0xE8, 0xF7, 0x08, 0x74, 0x19, 
+ 0xE8, 0xF7, 0x18, 0x08, 0x40, 0x06, 0x6C, 0x00, 
+ 0xED, 0xF2, 0x00, 0x02, 0x0C, 0xE8, 0xF7, 0x01, 
+ 0x19, 0xC6, 0x6D, 0xF2, 0x00, 0x04, 0x20, 0x7B, 
+ 0xED, 0xF2, 0x00, 0x02, 0x0D, 0xE8, 0xF7, 0x01, 
+ 0x19, 0xC6, 0x6D, 0xF2, 0x00, 0x04, 0x20, 0x6B, 
+ 0xE7, 0xF2, 0x00, 0x07, 0x27, 0x1E, 0x63, 0xF2, 
+ 0x00, 0x06, 0x26, 0xD4, 0x19, 0xC6, 0x6D, 0xF2, 
+ 0x00, 0x04, 0x20, 0x38, 0xE7, 0xF2, 0x00, 0x08, 
+ 0x27, 0x31, 0xED, 0xF2, 0x00, 0x02, 0x0D, 0xE8, 
+ 0xF7, 0x06, 0x20, 0x22, 0x62, 0xF2, 0x00, 0x06, 
+ 0x19, 0xC6, 0x6D, 0xF2, 0x00, 0x04, 0x20, 0x1C, 
+ 0xE7, 0xF2, 0x00, 0x08, 0x26, 0x0A, 0xE6, 0xF2, 
+ 0x00, 0x06, 0xC1, 0x05, 0x23, 0xA2, 0x20, 0x0B, 
+ 0x62, 0xF2, 0x00, 0x07, 0x20, 0x9A, 0x69, 0xF2, 
+ 0x00, 0x09, 0x00, 0x00, 0x69, 0xF2, 0x00, 0x08, 
+ 0xCD, 0x3C, 0x00, 0xEE, 0xF2, 0x00, 0x00, 0xCC, 
+ 0xFF, 0xFF, 0xAC, 0x31, 0x26, 0x07, 0x04, 0x36, 
+ 0xF9, 0x62, 0xF2, 0x00, 0x08, 0xED, 0xF2, 0x00, 
+ 0x04, 0x05, 0x40, 0xCC, 0x00, 0x0A, 0x20, 0x00, 
+ 0xCE, 0x07, 0xD0, 0xA7, 0x04, 0x35, 0xFC, 0x04, 
+ 0x34, 0xF6, 0xED, 0xF2, 0x00, 0x04, 0x05, 0x40 };
+/* The above was produced by assembling the following program with
+   > m6812-elf-as -o bdm12_eraseflash.o bdm12_eraseflash.s
+   > m6812-elf-objcopy.exe --change-addresses 0x800 -O srec bdm12_eraseflash.o
+     bdm12_eraseflash.s19
+   > ./convert < bdm12_eraseflash.s19 > bdm12_eraseflash.h
+
+   convert.c is listed following the assembly
+
+;-------------------bdm12_eraseflash.s-------------------
+;--------------------------------------------------------
+;--- Application Note Source Code for AN1836 ---
+;--- Erasing and Programming the FLASH ---
+;--- EEPROM on the MC68HC912B32 ---
+;--- ---
+;--- FLASH EEPROM erase routine ---
+;--- MC68HC912B32 1.5T FLASH Module ---
+;--- ---
+;--- Rev. 1.2 February 9, 2000 ---
+;--- Fixed bug in ReadArray routine ---
+;--- Created Bit Name Labels for easier reading ---
+;--- Streamlined Code for efficiency ---
+;--- Rev. 1.1 January 11, 2000 ---
+;--- Changed to 10ms delay for tepulse ---
+;--- to match specification change ---
+;--- Rev. 1.0 April 16, 1998 ---
+;--- Changed to 100ms delay for tepulse ---
+;--- Written November 6, 1997 ---
+;--- ---
+;--- ASSEMBLER: IASM12 v. 3.06 ---
+;--- P & E Microcomputer Systems ---
+;--- ---
+;--- by Matt Ruff, BE/OS Systems Engineering ---
+;--- ---
+;--- This code is intended for instructional use ---
+;--- only. Motorola assumes no liability for use ---
+;--- or modification of this code. It is the ---
+;--- responsibility of the user to verify all ---
+;--- parameters, variables, timings, etc. ---
+;--- ---
+;--------------------------------------------------------
+;----------------------------- Equates -----------------------------
+
+TmpStorage:
+FLASHStart:	.word 0x8000		;FLASH Start address
+REGStart:	.word 0x0		;Register Start Address
+SavePC:		.word 0x0		;saved PC
+Nep:		.byte 0			;Number of programming pulses applied
+MarginFlag:	.byte 0			;Programming margin flag
+ErasedFlag:	.byte 0			;Array Erased Flag
+ErrorFlag:	.byte 1			;Error Flag
+		.equ FLASHSize, 0x8000
+		.equ BootBlkSize, 0x800	;Size of the boot block
+		.equ BCFEEWords, ((FLASHSize-BootBlkSize)/2)
+				;Num of words to blank check
+		.equ MaxNep, 5		;5 pulses maximum
+		.equ FEELCK, 0xF4	;FLASH Lock Control Register
+		.equ FEEMCR, 0xF5	;FLASH Module Configuration Register
+		.equ FEECTL, 0xF7	;FLASH Control Register
+		.equ LOCK, 0x01		;Lock register Bit in FEELCK
+		.equ BOOTP, 0x01	;Boot Protect Bit in FEEMCR
+		.equ SVFP, 0x08		;Status Vfp Voltage Bit in FEECTL
+		.equ ERAS, 0x04		;Erase Control Bit in FEECTL
+		.equ LAT, 0x02		;Programming Latch Control bit in FEECTL
+		.equ ENPE, 0x01		;Enable Program/Erase Voltage Bit in FEECTL
+		.equ Mult, 1000		;Multiplier for EClock, assembler won't do
+					; values over 2^16
+		.equ EClock,(Mult*8000)	;E-clock frequency in Hz.
+		.equ mS1LoopTime, 4	;Num of clock cycles per loop.
+		.equ mS1Delay, (EClock/(mS1LoopTime*1000))
+					;Factor of 1000 used for base time of 1 ms.
+
+Start:
+		LEAS TmpStorage,PC
+		SEI			;disable interrupts - no SP
+		LDX FLASHStart,SP
+		CLR Nep,SP		;Clear number of pulses
+		CLR MarginFlag,SP	;Clear margin flag
+		CLR ErasedFlag,SP	;Clear erased flag
+		LDY REGStart,SP
+		BRCLR FEECTL,Y, SVFP,Error
+					;If Vfp not present, output an error
+;- Step 2 -
+		LEAY FEECTL,Y
+		MOVB #ERAS|LAT, 0,Y
+					;Set ERAS and LAT in FEECTL ( | is bitwise or)
+;- Step 3 -
+		STD 0,X			;Write some data to a valid FLASH address
+;- Step 4 -
+STEP4:
+		LDY REGStart,SP
+		BSET FEECTL,Y, ENPE	;Apply erase voltage (Set ENPE)
+;- Step 5 -
+		LEAY 6,PC
+		STY SavePC,SP
+		BRA dly_10ms		;Delay time for erase pulse (Tepulse)
+		
+;- Step 6 -
+		LDY REGStart,SP
+		BCLR FEECTL,Y, ENPE	;Remove erase voltage (Clear ENPE)
+;- Step 7 -
+		LEAY 6,PC
+		STY SavePC,SP
+		BRA dly_10ms		;Delay for high voltage turn off (Tverase)
+		TST MarginFlag,SP	;Is margin flag set??
+					; (TST sets Z bit in CCR if MarginFlag is 0)
+		BEQ NoFlag		;If not, go bump counter and check data
+					; (BEQ branches if MarginFlag is 0)
+YesFlag:
+		DEC Nep,SP		;Decrement Nep - mod. Z bit in CCR for coming
+					; BNE branch
+		BNE STEP4		;If Nep not 0, go to Step 4
+		LEAY 6,PC
+		STY SavePC,SP
+		BRA ReadArray		;Verify entire array is erased
+		TST ErasedFlag,SP	;Is the array erased?
+					; (TST sets Z bit in CCR if ErasedFlag is 0)
+		BEQ Error		;If not, Erase failed, output an error
+					; (BEQ branches if ErasedFlag is 0)
+;- Step 10 -
+		LDY REGStart,SP
+		BCLR FEECTL,Y, ERAS|LAT
+					;Clear ERAS and LAT in FEECTL
+		BRA Done		;If so, quit.
+NoFlag:
+		INC Nep,SP		;Increment number of erase pulses applied
+		LEAY 6,PC
+		STY SavePC,SP
+		BRA ReadArray		;Verify entire array is erased
+		TST ErasedFlag,SP	;Is it erased?
+					; (TST sets Z bit in CCR if ErasedFlag is 0)
+		BNE SetMarginFlag	;If so, set margin flag
+					; (BNE branches if ErasedFlag is 1)
+		LDAB Nep,SP
+		CMPB #MaxNep		;Have we applied max number of pulses?
+		BLS STEP4		;If not, continue erasing
+		BRA Error		;If so, we have a problem
+SetMarginFlag:
+		INC MarginFlag,SP	;Set Margin Flag
+		BRA STEP4
+Done:
+                CLR ErrorFlag,SP
+		BGND
+Error:
+		BGND
+;-----------------------------------------------------------------------
+;----------------- Read and Verify Erase subroutine ----------------
+;-----------------------------------------------------------------------
+ReadArray:
+		CLR ErasedFlag,SP	; Always start with clear flag.
+		LDY #BCFEEWords		; Num of words to check in FLASH. (No boot
+					; block check)
+		LDX FLASHStart,SP	; Index to the start of FLASH.
+		LDD #0xFFFF		; Erased word value for comparison.
+CheckLoop:
+		CPD 2,X+		; Is word erased?
+		BNE VerifyBad		; If not, return without setting ErasedFlag.
+					; (failure)
+		DBNE Y,CheckLoop	; Yes, Dec the word count, if not done check
+					; the next word.
+		INC ErasedFlag,SP	; All words checked & are erased. Set
+					; ErasedFlag.
+VerifyBad:
+		LDY SavePC,SP
+		JMP 0,Y
+;-----------------------------------------------------------------------
+;---------------------- Delay Subroutines -----------------------
+;-----------------------------------------------------------------------
+dly_10ms:
+		LDD #10 ;Delay for 10ms
+		BRA DelaymS
+
+;-----------------------------------------------------------------------
+;--- Millisecond Delay Routine ---
+;--- ---
+;--- Call with the number of mS to delay in the D accumulator. ---
+;--- The delay is not exact, but close enough when delaying ms. ---
+;-----------------------------------------------------------------------
+DelaymS:
+DlyLoop1mS:
+		LDX #mS1Delay		;Load 1ms delay count into X
+DlyLoop:
+		NOP			;Decrement count
+		DBNE X,DlyLoop		;Loop until done.
+		DBNE D,DlyLoop1mS
+		LDY SavePC,SP
+		JMP 0,Y
+------------------------convert.c---------------------------------------
+#include <stdio.h>
+#include <string.h>
+main()
+{
+  char line[200];
+  char *data = line + 8;
+  int i;
+  int count = 0;
+
+  printf ("unsigned char prog[] = {\n ");
+  while (fgets (line, 200, stdin))
+    {
+      if (strncmp (line, "S1", 2) != 0)
+        continue;
+      for (i = 0; i < strlen(data) - 4; i += 2)
+        {
+          printf ("0x");
+          putchar (data[i]);
+          putchar (data[i+1]);
+          printf (", ");
+          count++;
+          if (!(count % 8))
+            printf("\n ");
+        }
+    }
+    printf(" };\n");
+    printf("#define SIZE_PROG %d\n", count);
+}
+*/
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/bdm12_programflash.h gdb-6.4-m68hc1x/gdb/bdm12_programflash.h
--- gdb-6.4/gdb/bdm12_programflash.h	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/bdm12_programflash.h	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,236 @@
+#define BDM12_PROGRAMFLASH_SIZE 207
+#define BDM12_PROGRAMFLASH_FLASHSTART 0
+#define BDM12_PROGRAMFLASH_FLASHEND 2
+#define BDM12_PROGRAMFLASH_REGSTART 4
+#define BDM12_PROGRAMFLASH_DATASTART 6
+#define BDM12_PROGRAMFLASH_NUMWRITTEN 10
+#define BDM12_PROGRAMFLASH_PROGSTART 14
+
+unsigned char programflash[BDM12_PROGRAMFLASH_SIZE] = {
+ 0x80, 0x00, 0x80, 0x02, 0x00, 0x00, 0x09, 0x00, 
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1B, 0xD0, 
+ 0x14, 0x10, 0x87, 0xC7, 0x6C, 0xF2, 0x00, 0x0A, 
+ 0xEE, 0xF2, 0x00, 0x00, 0xED, 0xF2, 0x00, 0x04, 
+ 0x0E, 0xE8, 0xF7, 0x08, 0x04, 0x18, 0x20, 0x00, 
+ 0x8B, 0xED, 0xF2, 0x00, 0x06, 0x69, 0xF2, 0x00, 
+ 0x0C, 0x69, 0xF2, 0x00, 0x0D, 0x6D, 0xF2, 0x00, 
+ 0x08, 0xED, 0xF2, 0x00, 0x04, 0xC6, 0x02, 0x6B, 
+ 0xE8, 0xF7, 0xED, 0xF2, 0x00, 0x08, 0xE6, 0x40, 
+ 0x6B, 0x00, 0x6D, 0xF2, 0x00, 0x08, 0xED, 0xF2, 
+ 0x00, 0x04, 0x0C, 0xE8, 0xF7, 0x01, 0x19, 0xC2, 
+ 0x20, 0x65, 0xED, 0xF2, 0x00, 0x04, 0x0D, 0xE8, 
+ 0xF7, 0x01, 0x19, 0xC2, 0x20, 0x61, 0xED, 0xF2, 
+ 0x00, 0x08, 0xE7, 0xF2, 0x00, 0x0D, 0x27, 0x2A, 
+ 0x63, 0xF2, 0x00, 0x0C, 0xE7, 0xF2, 0x00, 0x0C, 
+ 0x26, 0xD0, 0xA6, 0x00, 0xA1, 0x40, 0x26, 0x34, 
+ 0x6D, 0xF2, 0x00, 0x08, 0xED, 0xF2, 0x00, 0x04, 
+ 0x0D, 0xE8, 0xF7, 0x02, 0xED, 0xF2, 0x00, 0x08, 
+ 0x08, 0x02, 0xAE, 0xF2, 0x00, 0x02, 0x26, 0x95, 
+ 0x20, 0x1A, 0x62, 0xF2, 0x00, 0x0C, 0xA6, 0x00, 
+ 0xA1, 0x40, 0x27, 0x0A, 0xE6, 0xF2, 0x00, 0x0C, 
+ 0xC1, 0x32, 0x23, 0x9E, 0x20, 0x06, 0x62, 0xF2, 
+ 0x00, 0x0D, 0x20, 0x96, 0xB7, 0x54, 0xA3, 0xF2, 
+ 0x00, 0x00, 0x6C, 0xF2, 0x00, 0x0A, 0x00, 0xCC, 
+ 0x00, 0x34, 0x04, 0x34, 0xFD, 0x05, 0x40, 0xCC, 
+ 0x00, 0x18, 0x04, 0x34, 0xFD, 0x05, 0x40  };
+
+/* The above was produced by assembling the following program with
+   > m6812-elf-as bdm12_programflash.s
+   > m6812-elf-objcopy.exe --change-addresses 0x800 -O srec
+     bdm12_programflash.o bdm12_programflash.s19
+   > ./convert < bdm12_programflash.s19 > bdm12_programflash.h
+
+   Convert.c is listed following the assembly
+
+;----------------bdm12_programflash.s-----------------
+;-----------------------------------------------------
+;--- Application Note Source Code for AN1836 ---
+;--- Erasing and Programming the FLASH ---
+;--- EEPROM on the MC68HC912B32 ---
+;--- ---
+;--- FLASH EEPROM program routine ---
+;--- MC68HC912B32 1.5T FLASH Module ---
+;--- ---
+;--- Rev. 1.2 February 9, 2000 ---
+;--- Created Bit Name Labels for easier reading---
+;--- Streamlined Code for efficiency ---
+;--- Rev. 1.0 - April 23,1998 ---
+;--- Fixed Tppulse = 25us and Tvprog = 10us ---
+;--- Written November 6, 1997 ---
+;--- ---
+;--- ASSEMBLER: IASM12 v. 3.06 ---
+;--- P & E Microcomputer Systems---
+;--- ---
+;--- by Matt Ruff, BE/OS Systems Engineering ---
+;--- ---
+;--- This code is intended for instructional use ---
+;--- only. Motorola assumes no liability for use ---
+;--- or modification of this code. It is the ---
+;--- responsibility of the user to verify all ---
+;--- parameters, variables, timings, etc. ---
+;--- ---
+;--------------------------------------------------------
+;------------------------------ Equates ----------------------------------
+		
+TmpStorage:
+FLASHStart:	.word 0x8000		;FLASH Start address
+FLASHEnd:	.word 0x8002		;FLASH End address (non-inclusive)
+REGStart:	.word 0x0	     	;Register Start address
+DATAStart:	.word 0x900		;Start of memory address to read from
+SaveY:		.word 0x0		;tmp storage for Y since I don't want
+					;to mess with stack
+NumWritten:	.word 0x0		;how many words have been written
+Npp:		.byte 0			;Number of programming pulses applied
+MarginFlag:	.byte 0			;Programming margin flag
+
+		.equ MaxNpp, 50		;50 pulses maximum
+		.equ FEELCK, 0xF4	;FLASH Lock Control Register
+		.equ FEEMCR, 0xF5	;FLASH Module Configuration Register
+		.equ FEECTL, 0xF7	;FLASH Control Register
+		.equ LOCK, 0x01		;Lock register Bit in FEELCK
+		.equ BOOTP, 0x01	;Boot Protect Bit in FEEMCR
+		.equ SVFP, 0x08		;Status Vfp Voltage Bit in FEECTL
+		.equ ERASE, 0x04	;Erase Control Bit in FEECTL
+		.equ LAT, 0x02		;Programming Latch Control bit in FEECTL
+		.equ ENPE, 0x01		;Enable Program/Erase Voltage Bit in FEECTL
+Start:
+                LEAS TmpStorage,PC	;Set SP to the beginning of tmp vars
+                SEI			;disable interrupts - no SP
+		CLRA
+		CLRB
+		STD NumWritten,SP	;Clear Num Bytes Written counter
+		LDX FLASHStart,SP
+		LDY REGStart,SP
+		BRSET FEECTL,Y, 8,NoError
+					;If Vfp not present, output an error
+		LBRA Done
+NoError:
+		LDY DATAStart,SP
+Loop:
+		CLR Npp,SP		;Clear number of pulses
+		CLR MarginFlag,SP	;Clear MarginFlag
+;- Step 2 -
+		STY SaveY,SP
+		LDY REGStart,SP
+		LDAB #LAT
+		STAB FEECTL,Y
+		LDY SaveY,SP
+				;Set LAT in FEECTL
+		LDAB 0,Y 	;Load from RAM
+;- Step 3 -
+		STAB 0,X	;Store in Flash
+;- Step 4 -
+STEP4:
+		STY SaveY,SP
+		LDY REGStart,SP
+		BSET FEECTL,Y,ENPE
+				;Apply programming voltage (Set ENPE)
+;- Step 5 -
+		LEAY 2,PC
+		BRA dly_22us	;Delay time for prog pulse (Tppulse)
+;- Step 6 -
+		LDY REGStart,SP
+		BCLR FEECTL,Y,ENPE
+				;Remove programming voltage (Clear ENPE)
+;- Step 7 -
+		LEAY 2,PC
+		BRA dly_10us	;Delay for high voltage turn off (Tvprog)
+		LDY SaveY,SP
+		TST MarginFlag,SP	;Is MarginFlag set??
+		BEQ NoFlag	;If not, go bump counter and check data
+YesFlag:
+		DEC Npp,SP	;Decrement Npp
+		TST Npp,SP	;Is Npp=0?
+		BNE STEP4	;If not, go to Step 4
+;- Step 9 -
+		LDAA 0,X	;Read FEEPROM location to verify programming
+		CMPA 0,Y	;Is it the same as the byte to be programmed?
+		BNE Done	;Programming failed, output an error
+;- Step 10 -
+		STY SaveY,SP
+		LDY REGStart,SP
+		BCLR FEECTL,Y,LAT	;Clear LAT in FEECTL
+		LDY SaveY,SP
+
+		INX
+		INY
+		CPX FLASHEnd,SP	;Check for end
+		BNE Loop	;If not, go back to start!
+		BRA Done	;If so, quit.
+NoFlag:
+		INC Npp,SP	;Increment number of prog pulses applied
+		LDAA 0,X	;Read FEEPROM location to verify programming
+		CMPA 0,Y	;Is it the same as the byte to be programmed?
+		BEQ SetMarginFlag
+				;If so, set the margin flag
+		LDAB Npp,SP
+		CMPB #MaxNpp	;Have we applied max number of pulses?
+		BLS STEP4	;If not, continue programming
+		BRA Done	;If so, we have a problem
+SetMarginFlag:
+		INC MarginFlag,SP	;Set MarginFlag
+		BRA STEP4
+Done:
+		TFR X, D
+		SUBD FLASHStart,SP
+		STD NumWritten,SP
+		BGND
+;-----------------------------------------------------------------------
+;---------------------- Delay Subroutines -----------------------
+;-----------------------------------------------------------------------
+;-----------------------------------------------------------------------
+;--- Microsecond Delay Routines (8MHz e clock) ---
+;--- ---
+;--- To reduce loop overhead, the following routines have been ---
+;--- optimized by counting cycle time and calculating the delay ---
+;--- based on an 8MHz system clock. ---
+;-----------------------------------------------------------------------
+dly_22us:			; Delay for about 22-23us
+; JSR or BSR is 4 cycles
+; Total delay is {4+2+(loopcount*3)+5}*125ns
+; For a loopcount of 52 yields 20.875us
+		LDD #52		; -2 cycles-
+d_22u:
+		DBNE D,d_22u	; -3 cycles-
+		JMP 0,Y
+				; -5 cycles-
+
+dly_10us:			; Delay for about 10us
+				; JSR or BSR is 4 cycles
+				; Total delay is {4+2+(loopcount*3)+5}*125ns
+				; For a loopcount of 24 yields 10.375us
+		LDD #24		; -2 cycles-
+d_10u:
+		DBNE D,d_10u	; -3 cycles-
+		JMP 0,Y
+				; -5 cycles-
+--------------------------------convert.c-------------------------------
+#include <stdio.h>
+#include <string.h>
+main()
+{
+  char line[200];
+  char *data = line + 8;
+  int i;
+  int count = 0;
+
+  printf ("unsigned char prog[] = {\n ");
+  while (fgets (line, 200, stdin))
+    {
+      if (strncmp (line, "S1", 2) != 0)
+        continue;
+      for (i = 0; i < strlen(data) - 4; i += 2)
+        {
+          printf ("0x");
+          putchar (data[i]);
+          putchar (data[i+1]);
+          printf (", ");
+          count++;
+          if (!(count % 8))
+            printf("\n ");
+        }
+    }
+    printf(" };\n");
+    printf("#define SIZE_PROG %d\n", count);
+}
+*/
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/config/m68hc11/m68hc11.mt gdb-6.4-m68hc1x/gdb/config/m68hc11/m68hc11.mt
--- gdb-6.4/gdb/config/m68hc11/m68hc11.mt	Wed Sep  3 17:02:50 2003
+++ gdb-6.4-m68hc1x/gdb/config/m68hc11/m68hc11.mt	Sat Jan 21 15:28:49 2006
@@ -1,5 +1,5 @@
 # Target: Motorola 68HC11 processor
-TDEPFILES= m68hc11-tdep.o
+TDEPFILES= m68hc11-tdep.o m68hc11-rom.o monitor.o dsrec.o remote-bdm12.o bdm12.o
 SIM_OBS= remote-sim.o
 SIM= ../sim/m68hc11/libsim.a -lm
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/dsrec.c gdb-6.4-m68hc1x/gdb/dsrec.c
--- gdb-6.4/gdb/dsrec.c	Sat Feb 12 01:39:18 2005
+++ gdb-6.4-m68hc1x/gdb/dsrec.c	Sat Jan 21 15:28:49 2006
@@ -49,7 +49,8 @@ static int make_srec (char *srec, CORE_A
 void
 load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
 	   int maxrecsize,
-	   int flags, int hashmark, int (*waitack) (void))
+	   int flags, int hashmark, int (*waitack) (void),
+           int (*serial_write) PARAMS ((struct serial*, char*, int)))
 {
   bfd *abfd;
   asection *s;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/m68hc11-rom.c gdb-6.4-m68hc1x/gdb/m68hc11-rom.c
--- gdb-6.4/gdb/m68hc11-rom.c	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/m68hc11-rom.c	Sat Jan 21 17:12:43 2006
@@ -0,0 +1,732 @@
+/* Remote target glue for various Motorola 68HC11/68HC12 monitors.
+   Copyright (C) 2000 Free Software Foundation, Inc.
+   Contributed by Stephane Carrez, stcarrez@worldnet.fr
+
+This file is part of GDB.
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
+
+
+#include "defs.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "monitor.h"
+#include "serial.h"
+#include "arch-utils.h"
+#include "event-loop.h"
+#include "event-top.h"
+#include "target.h"
+#include "inferior.h"
+#include <bfd/libbfd.h>
+#include <string.h>
+#ifndef __MINGW32__
+#include <sys/poll.h>
+#endif
+
+/* Register numbers of various important registers.  */
+#define HARD_X_REGNUM 	0
+#define HARD_D_REGNUM	1
+#define HARD_Y_REGNUM   2
+#define HARD_SP_REGNUM 	3
+#define HARD_PC_REGNUM 	4
+
+#define HARD_A_REGNUM   5
+#define HARD_B_REGNUM   6
+#define HARD_CCR_REGNUM 7
+#define M68HC11_LAST_HARD_REG (HARD_CCR_REGNUM)
+#define M68HC11_NUM_REGS (8)
+
+/* Switch gdb to use the given architecture.  The architecture is
+   controlled by the monitor we are connected to, not by our program.
+   Each time we connect to the monitor, update the gdb-arch to
+   reflect the target arch.  */
+static void
+set_gdbarch (enum bfd_architecture arch, unsigned long mach)
+{
+  struct gdbarch_info info;
+  bfd abfd;
+
+  bfd_default_set_arch_mach (&abfd, arch, mach);
+
+  memset (&info, 0, sizeof info);
+  info.bfd_arch_info = bfd_get_arch_info (&abfd);
+
+  if (!gdbarch_update_p (info))
+    {
+      internal_error (__FILE__, __LINE__,
+                      "monitor: failed to select architecture");
+    }
+}
+
+/* Special write routine to send monitor commands on the serial line.
+   The 68HC11/68HC12 have a 1 character SCI input queue.  When a character
+   is sent, it is echoed by the monitor.  SCI read/write operations are
+   made in polling mode.  Due to the 1 character length, the polling
+   and the echo, a character sent by Gdb can be lost.  We pad the
+   monitor command with a \0.  If the \0 is lost we don't care and
+   otherwise it is ignored by the monitor.  */
+static int
+m68hc11_serial_write (struct serial* scb, char* str, int len)
+{
+  int result = 0;
+  
+  while (len)
+    {
+      result = serial_write (scb, str, 1);
+      str++;
+      len--;
+      if (result)
+        break;
+
+      if (str[-1] == '\r' && len == 0)
+        break;
+      
+      /* Pad with a \0.  */
+      result = serial_write (scb, "", 1);
+      if (result)
+        break;
+    }
+  return result;
+}
+
+typedef struct console
+{
+  int escaped;
+  int escape_char;
+  int pos;
+  struct serial* target;
+  char cmd[256];
+  int cmdlen;
+  int interrupt;
+} *console_t;
+
+static struct console console_data;
+
+static int
+console_input (console_t cons, char c)
+{
+  int result;
+  
+  if (cons->escaped)
+    {
+      if (c == '.')
+        cons->interrupt = 1;
+
+      cons->escaped = 0;
+      return 0;
+    }
+  if (cons->pos == 0 && cons->escape_char == c)
+    {
+      cons->escaped = 1;
+      return 0;
+    }
+
+  result = serial_write (cons->target, &c, 1);
+  return 0;
+}
+
+static void
+do_console_input (gdb_client_data d)
+{
+  char c;
+  int result;
+  
+  result = read (input_fd, &c, 1);
+  if (result == 1)
+    {
+      console_input (&console_data, c);
+    }
+}
+
+static int
+m68hc11_wait_filter (char *buf,
+		     int bufmax,
+		     int *ext_resp_len,
+		     struct target_waitstatus *status)
+{
+  char c;
+  int result;
+  extern struct serial* monitor_desc;
+  int seen_zero = 0;
+  int timeout;
+  int i, cnt;
+#ifndef __MINGW32__
+  struct pollfd fds[2];
+
+  fds[0].fd = input_fd;
+  fds[0].events = POLLIN;
+  fds[1].fd = deprecated_serial_fd (monitor_desc);
+  fds[1].events = POLLIN;
+
+  console_data.escaped = 0;
+  console_data.escape_char = '~';
+  console_data.pos = 0;
+  console_data.target = monitor_desc;
+  console_data.interrupt = 0;
+  cnt = 0;
+  timeout = -1;
+  while (1)
+    {
+      gdb_flush (gdb_stdout);
+      result = poll (fds, 2, timeout);
+      if (result > 0 && (fds[0].revents & POLLIN))
+        {
+          do_console_input (0);
+        }
+      if (result > 0 && (fds[1].revents & POLLIN))
+        {
+          while (1)
+            {
+              c = serial_readchar (monitor_desc, 0);
+              if (c == SERIAL_TIMEOUT)
+                break;
+      
+              /* For Buffalo monitor, a \0 is printed before the prompt
+                 and before the monitor output in general.  */
+              if (seen_zero && c == '>')
+                {
+                  *ext_resp_len = 0;
+                  return 0;
+                }
+
+              /* If we see a \0, keep track of the characters for some
+                 delay to have a chance to identify the monitor prompt.
+                 If the delay is too long, what we received is printed
+                 as a standard output produced by the program.  */
+              if (c == 0)
+                {
+                  seen_zero++;
+                  timeout = 1000; /* 250 ms timeout  */
+                }
+              else if (seen_zero && step_range_end == 0)
+                {
+                  if (cnt < bufmax)
+                    buf[cnt++] = c;
+                }
+              /* Don't print when doing a single step.  */
+              else if (step_range_end == 0)
+                {
+                  putchar_unfiltered (c);
+                }
+            }
+        }
+      else if (result < 0)
+        {
+          for (i = 0; i < cnt; i++)
+            putchar_unfiltered (buf[i]);
+
+          cnt = 0;
+          seen_zero = 0;
+          timeout = -1;
+        }
+    }
+#else
+  int dt;
+  
+  console_data.escaped = 0;
+  console_data.escape_char = '~';
+  console_data.pos = 0;
+  console_data.target = monitor_desc;
+  console_data.interrupt = 0;
+  cnt = 0;
+  dt = 0;
+  timeout = -1;
+  while (1)
+    {
+      gdb_flush (gdb_stdout);
+      if (_rl_input_available ())
+        {
+          do_console_input (0);
+        }
+      result = serial_readchar (monitor_desc, 10);
+      if (result == SERIAL_TIMEOUT && (timeout < 0 || dt > 0))
+        {
+          if (timeout > 0)
+            dt--;
+          continue;
+        }
+      
+      if (result != SERIAL_TIMEOUT)
+        {
+          c = result;
+          while (1)
+            {
+              /* For Buffalo monitor, a \0 is printed before the prompt
+                 and before the monitor output in general.  */
+              if (seen_zero && c == '>')
+                {
+                  *ext_resp_len = 0;
+                  return 0;
+                }
+
+              /* If we see a \0, keep track of the characters for some
+                 delay to have a chance to identify the monitor prompt.
+                 If the delay is too long, what we received is printed
+                 as a standard output produced by the program.  */
+              if (c == 0)
+                {
+                  seen_zero++;
+                  timeout = 1000; /* 250 ms timeout  */
+                }
+              else if (seen_zero && step_range_end == 0)
+                {
+                  if (cnt < bufmax)
+                    buf[cnt++] = c;
+                }
+              /* Don't print when doing a single step.  */
+              else if (step_range_end == 0)
+                {
+                  putchar_unfiltered (c);
+                }
+
+              c = serial_readchar (monitor_desc, 0);
+              if (c == SERIAL_TIMEOUT)
+                break;
+            }
+          if (timeout > 0)
+            dt = timeout / 10;
+        }
+      else
+        {
+          for (i = 0; i < cnt; i++)
+            putchar_unfiltered (buf[i]);
+
+          cnt = 0;
+          seen_zero = 0;
+          timeout = -1;
+        }
+    }
+#endif
+  return 0;
+}
+
+
+/* Buffalo 68HC11 monitor.  */
+
+static void buffalo_open (char *args, int from_tty);
+
+/* This array of registers needs to match the indexes used by GDB.  The
+   whole reason this exists is because the various ROM monitors use
+   different names than GDB does, and don't support all the registers
+   either.  So, typing "info reg sp" becomes an "S".  */
+
+static char *buffalo_regnames[M68HC11_NUM_REGS] =
+{
+  "X", NULL, "Y", "S", "P", "A", "B", "C"
+};
+
+static struct target_ops buffalo_ops;
+static struct monitor_ops buffalo_cmds;
+
+/* Initialization strings to wakeup the monitor.
+   Send both \r and \030 (^X) to abort a possible current command.  */
+static char *buffalo_inits[] = {
+  /* First command to invalidate a possible command ('~') and
+     to acknowledge the monitor after a reset ('\r').  */
+  "~\r",
+
+  /* Second command ^X to abort a possible current command
+     such as 'asm' and 'rm'.  */
+  "\030",
+  NULL
+};
+
+static int
+m68hc11_dumpregs (void)
+{
+  char buf[256];
+  int resp_len;
+  char *p;
+  char reg_d[5];
+  
+  /* Send the dump register command to the monitor and
+     get the reply.  */
+  monitor_printf ("rd\r");
+  resp_len = monitor_expect ("\r", buf, sizeof (buf));
+
+  memset (reg_d, 0, sizeof (reg_d));
+  p = buf;
+  while (p && (p[0] == '\r' || p[0] == '\n'))
+    p++;
+  
+  while (p && p[0] != '\r' && p[0] != '\n' && p[1] == '-')
+    {
+      int reg;
+      char *q;
+      
+      if (p[0] == 'P')
+        reg = HARD_PC_REGNUM;
+      else if (p[0] == 'Y')
+        reg = HARD_Y_REGNUM;
+      else if (p[0] == 'X')
+        reg = HARD_X_REGNUM;
+      else if (p[0] == 'S')
+        reg = HARD_SP_REGNUM;
+      else if (p[0] == 'C')
+        reg = HARD_CCR_REGNUM;
+      else if (p[0] == 'A')
+        reg = HARD_A_REGNUM;
+      else if (p[0] == 'B')
+        reg = HARD_B_REGNUM;
+      else
+        break;
+
+      q = &p[2];
+      p = strchr (q, ' ');
+      if (p == 0)
+        p = strchr (q, '\t');
+      if (p == 0)
+        p = strchr (q, '\n');
+      if (p)
+        *p++ = 0;
+
+      if (reg == HARD_A_REGNUM)
+        {
+          reg_d[0] = q[0];
+          reg_d[1] = q[1];
+        }
+      else if (reg == HARD_B_REGNUM)
+        {
+          reg_d[2] = q[0];
+          reg_d[3] = q[1];
+        }
+      monitor_supply_register (reg, q);
+    }
+
+  /* If we got the value of both A and B, set the value of D.  */
+  if (reg_d[0] && reg_d[2])
+    monitor_supply_register (HARD_D_REGNUM, reg_d);
+
+
+  monitor_expect (" ", 0, 0);
+  monitor_printf_noecho ("\r");
+  monitor_expect_prompt (0, 0);
+  return 0;
+}
+
+static void
+init_buffalo_cmds (void)
+{
+  buffalo_cmds.dumpregs = m68hc11_dumpregs;
+  buffalo_cmds.flags = MO_NO_ECHO_ON_OPEN | MO_GETMEM_16_BOUNDARY |
+    MO_SETMEM_INTERACTIVE | MO_SETREG_INTERACTIVE |
+    MO_CLR_BREAK_USES_ADDR | MO_GETMEM_NEEDS_RANGE | MO_FILL_USES_ADDR;
+  buffalo_cmds.init = buffalo_inits;	/* Init strings */
+  buffalo_cmds.cont = "p\r";            /* continue command */
+  buffalo_cmds.step = "t 1\r";          /* single step */
+  buffalo_cmds.stop = NULL;             /* interrupt command */
+  buffalo_cmds.set_break = "br %x\r";	/* set a breakpoint */
+  buffalo_cmds.clr_break = "br -%x\r";	/* clear a breakpoint */
+  buffalo_cmds.clr_all_break = "br -\r";	/* clear all breakpoints */
+  buffalo_cmds.fill = "bf %x %x %x\r";	/* fill (start end val) */
+  buffalo_cmds.setmem.cmdb = "mm %x\r";	/* setmem.cmdb (addr, value) */
+  buffalo_cmds.setmem.cmdw = NULL;
+  buffalo_cmds.setmem.cmdl = NULL;
+  buffalo_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
+  buffalo_cmds.setmem.resp_delim = "[\r\n]*[0-9a-fA-F]+ [0-9a-fA-F]+ ";
+  buffalo_cmds.setmem.term = NULL;	/* setmem.term */
+  buffalo_cmds.setmem.term_cmd = NULL;	/* setmem.term_cmd */
+  buffalo_cmds.getmem.cmdb = "md %x %x\r";	/* getmem.cmdb (addr, addr2) */
+  buffalo_cmds.getmem.cmdw = NULL;
+  buffalo_cmds.getmem.cmdl = NULL;
+  buffalo_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, addr2) */
+  buffalo_cmds.getmem.resp_delim = " ";	/* getmem.resp_delim */
+  buffalo_cmds.getmem.term = NULL;	/* getmem.term */
+  buffalo_cmds.getmem.term_cmd = NULL;	/* getmem.term_cmd */
+  buffalo_cmds.setreg.cmd = "rm %s\r";	/* setreg.cmd (name, value) */
+  buffalo_cmds.setreg.resp_delim =
+    "\nP.*S\\-[0-9a-fA-F]+ [\r\n]+.[PXYABCS]\\-[0-9a-fA-F]+ ";
+  buffalo_cmds.setreg.term = NULL;	/* setreg.term */
+  buffalo_cmds.setreg.term_cmd = NULL;	/* setreg.term_cmd */
+  buffalo_cmds.getreg.cmd = NULL;	/* getreg.cmd (name) */
+  buffalo_cmds.getreg.resp_delim = NULL;/* getreg.resp_delim */
+  buffalo_cmds.getreg.term = NULL;	/* getreg.term */
+  buffalo_cmds.getreg.term_cmd = NULL;	/* getreg.term_cmd */
+  buffalo_cmds.dump_registers = NULL;   /* dump_registers */
+  /* register_pattern */
+  buffalo_cmds.register_pattern = NULL;
+  buffalo_cmds.supply_register = NULL;	/* supply_register */
+  buffalo_cmds.load_routine = NULL;	/* load_routine (defaults to SRECs) */
+  buffalo_cmds.load = "load t\r";	/* download command */
+  buffalo_cmds.loadresp = NULL;	/* load response */
+  buffalo_cmds.prompt = ">";	/* monitor command prompt */
+  buffalo_cmds.line_term = "\r";	/* end-of-line terminator */
+  buffalo_cmds.cmd_end = NULL;	/* optional command terminator */
+  buffalo_cmds.target = &buffalo_ops;	/* target operations */
+  buffalo_cmds.stopbits = SERIAL_2_STOPBITS;	/* number of stop bits */
+  buffalo_cmds.regnames = buffalo_regnames;	/* registers names */
+  buffalo_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
+  buffalo_cmds.serial_write = m68hc11_serial_write;
+  buffalo_cmds.wait_filter = m68hc11_wait_filter;
+}
+
+static void
+buffalo_open (char *args, int from_tty)
+{
+  monitor_open (args, &buffalo_cmds, from_tty);
+  set_gdbarch (bfd_arch_m68hc11, 0);
+}
+
+
+/* DBug 68HC12 monitor.  */
+
+static void dbug_open (char *args, int from_tty);
+
+/* This array of registers needs to match the indexes used by GDB.  The
+   whole reason this exists is because the various ROM monitors use
+   different names than GDB does, and don't support all the registers
+   either.  So, typing "info reg sp" becomes an "S".  */
+
+static char *dbug_regnames[M68HC11_NUM_REGS] =
+{
+  "X", "D", "Y", "SP", "PC", "A", "B", "CCR"
+};
+
+static struct target_ops dbug_ops;
+static struct monitor_ops dbug_cmds;
+
+/* Initialization strings to wakeup the monitor.
+   Send both \r and \030 (^X) to abort a possible current command.  */
+static char *dbug_inits[] =
+{ "\r\030", NULL};
+
+static int
+dbug_dumpregs (void)
+{
+  char buf[256];
+  int resp_len;
+  char *p;
+  int i;
+  static int reg_list[] = {
+    HARD_PC_REGNUM,
+    HARD_SP_REGNUM,
+    HARD_X_REGNUM,
+    HARD_Y_REGNUM,
+    HARD_D_REGNUM,
+    -1
+  };
+
+  /* Send the dump register command to the monitor and
+     get the reply.  */
+  monitor_printf ("rd\r");
+  monitor_printf_noecho ("\r");
+  resp_len = monitor_expect_prompt (buf, sizeof (buf));
+
+  p = buf;
+  while (p && strncmp (p, "CCR = SXHI NZVC", 15) != 0)
+    p++;
+
+  if (p == 0)
+    {
+      return -1;
+    }
+  
+  /* Skip the CCR marker.  */
+  while (p && p[0] != '\r' && p[0] != '\n')
+    p++;
+
+  /* Skip end of line markers.  */
+  while (p && (p[0] == '\r' || p[0] == '\n'))
+    p++;
+  
+  for (i = 0; p && reg_list[i] >= 0; i++)
+    {
+      char *q;
+
+      q = strchr (p, ' ');
+      if (q == 0)
+        q = strchr (p, '\t');
+
+      if (q)
+        *q++ = 0;
+
+      /* Value for register D is split with ':' ex: 45:23.  */
+      if (p[2] == ':')
+        {
+          p[2] = p[1];
+          p[1] = p[0];
+          p++;
+        }
+      monitor_supply_register (reg_list[i], p);
+      p = q;
+      while (p && p[0] == ' ')
+        p++;
+    }
+
+  /* Last value is the CCR expressed in bits.  */
+  if (p)
+    {
+      int bit, val;
+
+      val = 0;
+      for (bit = 7; p[0] && bit >= 0; )
+        {
+          char c = *p++;
+
+          if (c == ' ')
+            continue;
+
+          if (c == '1')
+            val |= (1 << bit);
+          bit--;
+        }
+      sprintf (buf, "%x", val);
+      monitor_supply_register (HARD_CCR_REGNUM, buf);
+    }
+  return 0;
+}
+
+static int (* monitor_xfer_memory) (CORE_ADDR, gdb_byte*, int, int,
+                                    struct mem_attrib *attrib,
+                                    struct target_ops*);
+
+static int
+dbug_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
+                  struct mem_attrib *attrib,
+                  struct target_ops *target)
+{
+  unsigned char val;
+  int written = 0;
+  char buf[16];
+  int result;
+
+  if (write == 0)
+    return monitor_xfer_memory (memaddr, myaddr, len, write, attrib, target);
+
+  if (len == 0)
+    return 0;
+
+  /* Enter the sub mode */
+  monitor_printf ("mm %x\r", (int) memaddr);
+
+  /* Wait output (7 chars); If we get the prompt, that's too bad.  */
+  result = monitor_expect (">", buf, 8);
+  if (result > 0)
+    return 0;
+  
+  while (len)
+    {
+      val = *myaddr;
+      monitor_printf ("%x\r", val);
+
+      result = monitor_expect (">", buf, 8);
+      if (result > 0)
+        return written;
+      
+      myaddr++;
+      memaddr++;
+      written++;
+      /* If we wanted to, here we could validate the address */
+      len--;
+    }
+  /* Now exit the sub mode */
+  monitor_printf (".\r");
+  monitor_expect_prompt (NULL, 0);
+  return written;
+}
+
+static void
+init_dbug_cmds (void)
+{
+  dbug_cmds.dumpregs = dbug_dumpregs;
+  dbug_cmds.flags = MO_NO_ECHO_ON_OPEN | MO_GETMEM_16_BOUNDARY |
+    MO_SETMEM_INTERACTIVE |
+    MO_CLR_BREAK_USES_ADDR | MO_GETMEM_NEEDS_RANGE | MO_FILL_USES_ADDR;
+  dbug_cmds.init = dbug_inits;	/* Init strings */
+  dbug_cmds.cont = "g\r";            /* continue command */
+  dbug_cmds.step = "t 1\r";          /* single step */
+  dbug_cmds.stop = NULL;             /* interrupt command */
+  dbug_cmds.set_break = "br %x\r";	/* set a breakpoint */
+  dbug_cmds.clr_break = "nobr %x\r";	/* clear a breakpoint */
+  dbug_cmds.clr_all_break = "nobr\r";	/* clear all breakpoints */
+  dbug_cmds.fill = "bf %x %x %x\r";	/* fill (start end val) */
+  dbug_cmds.setmem.cmdb = "mm %x\r";	/* setmem.cmdb (addr, value) */
+  dbug_cmds.setmem.cmdw = NULL;
+  dbug_cmds.setmem.cmdl = NULL;
+  dbug_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
+  dbug_cmds.setmem.resp_delim = NULL;
+  dbug_cmds.setmem.term = NULL;	/* setmem.term */
+  dbug_cmds.setmem.term_cmd = ".\r";	/* setmem.term_cmd */
+  dbug_cmds.getmem.cmdb = "md %x %x\r";	/* getmem.cmdb (addr, addr2) */
+  dbug_cmds.getmem.cmdw = NULL;
+  dbug_cmds.getmem.cmdl = NULL;
+  dbug_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, addr2) */
+  dbug_cmds.getmem.resp_delim = " ";	/* getmem.resp_delim */
+  dbug_cmds.getmem.term = NULL;	/* getmem.term */
+  dbug_cmds.getmem.term_cmd = NULL;	/* getmem.term_cmd */
+  dbug_cmds.setreg.cmd = "%s %x\r";	/* setreg.cmd (name, value) */
+  dbug_cmds.setreg.resp_delim = NULL;
+  dbug_cmds.setreg.term = NULL;	/* setreg.term */
+  dbug_cmds.setreg.term_cmd = NULL;	/* setreg.term_cmd */
+  dbug_cmds.getreg.cmd = NULL;	/* getreg.cmd (name) */
+  dbug_cmds.getreg.resp_delim = " ";	/* getreg.resp_delim */
+  dbug_cmds.getreg.term = NULL;	/* getreg.term */
+  dbug_cmds.getreg.term_cmd = NULL;	/* getreg.term_cmd */
+  dbug_cmds.dump_registers = NULL;;     /* dump_registers */
+  /* register_pattern */
+  dbug_cmds.register_pattern = NULL;
+  dbug_cmds.supply_register = NULL;	/* supply_register */
+  dbug_cmds.load_routine = NULL;	/* load_routine (defaults to SRECs) */
+  dbug_cmds.load = "load\r";	/* download command */
+  dbug_cmds.loadresp = NULL;	/* load response */
+  dbug_cmds.prompt = ">";	/* monitor command prompt */
+  dbug_cmds.line_term = "\r";	/* end-of-line terminator */
+  dbug_cmds.cmd_end = NULL;	/* optional command terminator */
+  dbug_cmds.target = &dbug_ops;	/* target operations */
+  dbug_cmds.stopbits = SERIAL_2_STOPBITS;	/* number of stop bits */
+  dbug_cmds.regnames = dbug_regnames;	/* registers names */
+  dbug_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
+}
+
+static void
+dbug_open (char *args, int from_tty)
+{
+  monitor_open (args, &dbug_cmds, from_tty);
+  set_gdbarch (bfd_arch_m68hc12, 0);
+}
+
+
+/* Initialize all 68HC11/68HC12 monitors.  */
+
+void
+_initialize_m68hc11_rom (void)
+{
+  /* 68HC11 Buffalo monitor.  */
+  init_buffalo_cmds ();
+  init_monitor_ops (&buffalo_ops);
+
+  buffalo_ops.to_shortname = "buffalo";
+  buffalo_ops.to_longname = "Buffalo monitor";
+  buffalo_ops.to_doc = "Debug via the Buffalo 68HC11 monitor.\n\
+Specify the serial device it is connected to (e.g. /dev/ttya).";
+  buffalo_ops.to_open = buffalo_open;
+
+  add_target (&buffalo_ops);
+
+  /* 68HC12 DBug monitor.  */
+  init_dbug_cmds ();
+  init_monitor_ops (&dbug_ops);
+
+  dbug_ops.to_shortname = "dbug";
+  dbug_ops.to_longname = "DBug monitor";
+  dbug_ops.to_doc = "Debug via the DBug 68HC12 monitor.\n\
+Specify the serial device it is connected to (e.g. /dev/ttya).";
+  dbug_ops.to_open = dbug_open;
+  monitor_xfer_memory = dbug_ops.deprecated_xfer_memory;
+  dbug_ops.deprecated_xfer_memory = dbug_xfer_memory;
+  
+  add_target (&dbug_ops);
+} 
+
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/monitor.c gdb-6.4-m68hc1x/gdb/monitor.c
--- gdb-6.4/gdb/monitor.c	Fri Feb 18 19:58:56 2005
+++ gdb-6.4-m68hc1x/gdb/monitor.c	Sat Jan 21 15:28:49 2006
@@ -122,7 +122,7 @@ static CORE_ADDR *breakaddr;
    that monitor_open knows that we don't have a file open when the
    program starts.  */
 
-static struct serial *monitor_desc = NULL;
+struct serial *monitor_desc = NULL;
 
 /* Pointer to regexp pattern matching data */
 
@@ -138,6 +138,12 @@ static char setmem_resp_delim_fastmap[25
 static struct re_pattern_buffer setreg_resp_delim_pattern;
 static char setreg_resp_delim_fastmap[256];
 
+static struct re_pattern_buffer setmem_resp_delim_pattern;
+static char setmem_resp_delim_fastmap[256];
+
+static struct re_pattern_buffer setreg_resp_delim_pattern;
+static char setreg_resp_delim_fastmap[256];
+
 static int dump_reg_flag;	/* Non-zero means do a dump_registers cmd when
 				   monitor_wait wakes up.  */
 
@@ -2161,7 +2167,8 @@ monitor_load (char *file, int from_tty)
       load_srec (monitor_desc, file, (bfd_vma) load_offset,
 		 32, SREC_ALL, hashmark,
 		 current_monitor->flags & MO_SREC_ACK ?
-		 monitor_wait_srec_ack : NULL);
+		 monitor_wait_srec_ack : NULL,
+                 current_monitor->serial_write);
 
       monitor_expect_prompt (NULL, 0);
     }
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/monitor.h gdb-6.4-m68hc1x/gdb/monitor.h
--- gdb-6.4/gdb/monitor.h	Tue Aug  5 04:44:50 2003
+++ gdb-6.4-m68hc1x/gdb/monitor.h	Sat Jan 21 15:28:49 2006
@@ -109,6 +109,7 @@ struct monitor_ops
 			int bufmax,
 			int *response_length,
 			struct target_waitstatus * status);
+    int (*serial_write) (struct serial*, char* buf, int buflen);
     char *load;			/* load command */
     char *loadresp;		/* Response to load command */
     char *prompt;		/* monitor command prompt */
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/remote-bdm12.c gdb-6.4-m68hc1x/gdb/remote-bdm12.c
--- gdb-6.4/gdb/remote-bdm12.c	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/remote-bdm12.c	Sat Jan 21 17:09:25 2006
@@ -0,0 +1,718 @@
+/* remote debugging interface for Kevin Ross' BDM12 BDM pod for the 68HC12.
+   Copyright 2001
+   Free Software Foundation, Inc.
+   Contributed by Tim Housel (thousel@usa.net)
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "inferior.h"
+#include "value.h"
+#include "gdb_string.h"
+#include <ctype.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <errno.h>
+#include "terminal.h"
+#include "target.h"
+#include "gdbcore.h"
+#include "gdb/callback.h"
+#include "gdb/signals.h"
+#include "bdm12.h"
+#include "remote-utils.h"
+#include "command.h"
+#include "regcache.h"
+
+/* Prototypes */
+
+extern void _initialize_remote_bdm12 (void);
+
+static void dump_mem (char *buf, int len);
+
+static void gdbbdm12_fetch_register (int regno);
+
+static void gdbbdm12_store_register (int regno);
+
+static void gdbbdm12_kill (void);
+
+static void gdbbdm12_load (char *prog, int fromtty);
+
+static void gdbbdm12_create_inferior (char *exec_file, char *args, char **env, int);
+
+static void gdbbdm12_open (char *args, int from_tty);
+
+static void gdbbdm12_close (int quitting);
+
+static void gdbbdm12_detach (char *args, int from_tty);
+
+static void gdbbdm12_resume (ptid_t pid, int step, enum target_signal siggnal);
+
+static ptid_t gdbbdm12_wait (ptid_t pid, struct target_waitstatus *status);
+
+static void gdbbdm12_prepare_to_store (void);
+struct mem_attrib;
+static int gdbbdm12_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, 
+                                          int len, int write,
+                                          struct mem_attrib *attrib,
+                                          struct target_ops *target);
+
+static void gdbbdm12_files_info (struct target_ops *target);
+
+static void gdbbdm12_mourn_inferior (void);
+
+static void gdbbdm12_stop (void);
+
+static int gdbbdm12_insert_breakpoint (CORE_ADDR addr, gdb_byte *contents_cache);
+
+static int gdbbdm12_remove_breakpoint (CORE_ADDR addr, gdb_byte *contents_cache);
+
+void pass_command (char *args, int from_tty);
+
+/* Naming convention:
+
+   bdm12_* are the interface to the BDM Hardware (see bdm12.h).
+   gdbbdm12_* are stuff which is internal to gdb.  */
+
+/* Forward data declarations */
+extern struct target_ops gdbbdm12_ops;
+
+static int program_loaded = 0;
+
+/* We must keep track of whether the BDM has been opened or not because
+   GDB can call a target's close routine twice, but bdm12_close doesn't allow
+   this.  We also need to record the result of bdm12_open so we can pass it
+   back to the other bdm12_foo routines.  */
+static int gdbbdm12_opened = 0;
+
+static int bdm12_stop_requested = 0;
+
+static void
+dump_mem (char *buf, int len)
+{
+  if (len <= 8)
+    {
+      if (len == 8 || len == 4)
+        {
+          long l[2];
+          memcpy (l, buf, len);
+          printf_filtered ("\t0x%lx", l[0]);
+          if (len == 8)
+            printf_filtered (" 0x%lx", l[1]);
+          printf_filtered ("\n");
+        }
+      else
+        {
+          int i;
+          printf_filtered ("\t");
+          for (i = 0; i < len; i++)
+            printf_filtered ("0x%x ", buf[i]);
+          printf_filtered ("\n");
+        }
+    }
+}
+
+static void
+gdbbdm12_fetch_register (int regno)
+{
+  static int warn_user = 1;
+  if (regno == -1)
+    {
+      for (regno = 0; regno < NUM_REGS; regno++)
+        gdbbdm12_fetch_register (regno);
+    }
+  else if (REGISTER_NAME (regno) != NULL
+           && *REGISTER_NAME (regno) != '\0')
+    {
+      char buf[MAX_REGISTER_SIZE];
+      int nr_bytes;
+      if (REGISTER_BDM12_REGNO (regno) >= 0)
+        nr_bytes = bdm12_fetch_register (REGISTER_BDM12_REGNO (regno),
+                                         buf, register_size (current_gdbarch, regno));
+      else
+        nr_bytes = 0;
+      if (nr_bytes == 0)
+        /* register not applicable, supply zero's */
+        memset (buf, 0, MAX_REGISTER_SIZE);
+      else if (nr_bytes > 0 && nr_bytes != register_size (current_gdbarch, regno)
+               && warn_user)
+        {
+          fprintf_unfiltered (gdb_stderr,
+                              "Size of register %s (%d/%d) incorrect (%d instead of %d))",
+                              REGISTER_NAME (regno),
+                              regno, REGISTER_BDM12_REGNO (regno),
+                              nr_bytes, register_size (current_gdbarch, regno));
+          warn_user = 0;
+      }
+      regcache_raw_supply (current_regcache, regno, buf);
+      if (sr_get_debug ())
+        {
+          printf_filtered ("gdbbdm12_fetch_register: %d", regno);
+          /* FIXME: We could print something more intelligible.  */
+          dump_mem (buf, register_size (current_gdbarch, regno));
+        }
+    }
+}
+
+
+static void
+gdbbdm12_store_register (int regno)
+{
+  if (regno == -1)
+    {
+      for (regno = 0; regno < NUM_REGS; regno++)
+        gdbbdm12_store_register (regno);
+    }
+  else if (REGISTER_NAME (regno) != NULL
+           && *REGISTER_NAME (regno) != '\0'
+           && REGISTER_BDM12_REGNO (regno) >= 0)
+    {
+      char tmp[MAX_REGISTER_SIZE];
+      int nr_bytes;
+      deprecated_read_register_gen (regno, tmp);
+      nr_bytes = bdm12_store_register (REGISTER_BDM12_REGNO (regno),
+                                       tmp, register_size (current_gdbarch, regno));
+      if (nr_bytes > 0 && nr_bytes != register_size (current_gdbarch, regno))
+        internal_error (__FILE__, __LINE__,
+                        "Register size different than expected");
+      if (sr_get_debug ())
+        {
+          printf_filtered ("gdbbdm12_store_register: %d", regno);
+          /* FIXME: We could print something more intelligible.  */
+          dump_mem (tmp, register_size (current_gdbarch, regno));
+        }
+    }
+}
+
+/* Kill the running program. */
+
+static void
+gdbbdm12_kill (void)
+{
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_kill\n");
+
+  /* make sure everything is closed up okay (e.g. serial port) */
+
+  bdm12_close (1);
+  inferior_ptid = null_ptid;
+}
+
+/* Load an executable file into the target process.  This is expected to
+   not only bring new code into the target process, but also to update
+   GDB's symbol tables to match.  */
+
+static void
+gdbbdm12_load (char *prog, int fromtty)
+{
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_load: prog \"%s\"\n", prog);
+
+  inferior_ptid = null_ptid;
+
+  /* FIXME: We will print two messages on error.
+     Need error to either not print anything if passed NULL or need
+     another routine that doesn't take any arguments.  */
+  if (bdm12_load (prog, NULL, fromtty) == BDM12_RC_FAIL)
+    error ("unable to load program");
+
+  /* FIXME: If a load command should reset the targets registers then
+     a call to bdm12_create_inferior() should go here. */
+
+  program_loaded = 1;
+}
+
+
+/* Start an inferior process and set inferior_pid to its pid.
+   EXEC_FILE is the file to run.
+   ARGS is a string containing the arguments to the program.
+   ENV is the environment vector to pass.  Errors reported with error().
+   This is called not only when we first attach, but also when the
+   user types "run" after having attached.  */
+
+static void
+gdbbdm12_create_inferior (char *exec_file, char *args, char **env, int from_tty)
+{
+  int len;
+  char *arg_buf, **argv;
+
+  if (exec_file == 0 || exec_bfd == 0)
+    warning ("No executable file specified.");
+  if (!program_loaded)
+    warning ("No program loaded.");
+  if (!gdbbdm12_opened)
+      error ("Not connected to the bdm12 interface");
+
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_create_inferior: exec_file \"%s\", args \"%s\"\n",
+                     (exec_file ? exec_file : "(NULL)"),
+                     args);
+
+  remove_breakpoints ();
+  init_wait_for_inferior ();
+
+  if (exec_file != NULL)
+    {
+      len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
+      arg_buf = (char *) alloca (len);
+      arg_buf[0] = '\0';
+      strcat (arg_buf, exec_file);
+      strcat (arg_buf, " ");
+      strcat (arg_buf, args);
+      argv = buildargv (arg_buf);
+      make_cleanup_freeargv (argv);
+    }
+  else
+    argv = NULL;
+  bdm12_create_inferior (exec_bfd, argv, env);
+
+  inferior_ptid = pid_to_ptid (42);
+  insert_breakpoints ();
+
+  clear_proceed_status ();
+
+  /* NB: Entry point already set by bdm12_create_inferior. */
+  proceed ((CORE_ADDR) -1, TARGET_SIGNAL_DEFAULT, 0);
+}
+
+/* The open routine takes the rest of the parameters from the command,
+   and (if successful) pushes a new target onto the stack.
+   Called when selecting the bdm12 target. EG: (gdb) target bdm12 name.  */
+
+static void
+gdbbdm12_open (char *args, int from_tty)
+{
+  int len;
+  char **argv;
+  BDM12_RC retval;
+
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_open: args \"%s\"\n", args ? args : "(null)");
+
+  /* Remove current bdm12 if one exists.  Only do this if the bdm12 interface
+     has been opened because bdm12_close requires it.
+     This is important because the call to push_target below will cause
+     bdm12_close to be called if the bdm12 interface is already open, but
+     push_target is called after bdm12_open!  We can't move the call to
+     push_target before the call to bdm12_open because bdm12_open may invoke
+     'error'.  */
+
+  if (args == NULL)
+    error("\n\
+Usage: target bdm12 <serial_device> <E-clock rate (1,2,4, or 8 MHz) \n\
+                           <register base> <ram base> <eeprom base> <flash base> \n\
+(ex. target bdm12 com1 8 0x0 0x800 0xd00 0x8000 on Win32, \n\
+  or target bdm12 ttya 8 0x0 0x800 0xd00 0x8000 on UNIX)");
+
+  if (gdbbdm12_opened != 0)
+    unpush_target (&gdbbdm12_ops);
+
+  argv = buildargv (args);
+  if (argv == NULL)
+    error("Insufficient memory available to allocate arg list");
+  make_cleanup_freeargv (argv);
+
+  retval = bdm12_open (argv);
+  if (retval != BDM12_RC_OK)
+    error ("unable to open bdm12 interface\n\
+Usage: target bdm12 <serial_device> <E-clock rate (1,2,4, or 8 MHz) \n\
+                    <register base> <ram base> <eeprom base> <flash base> \n\
+(ex. target bdm12 com1 8 0x0 0x800 0xd00 0x8000 on Win32, \n\
+  or target bdm12 ttya 8 0x0 0x800 0xd00 0x8000 on UNIX)");
+  else
+    gdbbdm12_opened = 1;
+
+  push_target (&gdbbdm12_ops);
+  target_fetch_registers (-1);
+  printf_filtered ("Connected to the bdm12 interface.\n");
+}
+
+/* Does whatever cleanup is required for a target that we are no longer
+   going to be calling.  Argument says whether we are quitting gdb and
+   should not get hung in case of errors, or whether we want a clean
+   termination even if it takes a while.  This routine is automatically
+   always called just before a routine is popped off the target stack.
+   Closing file and freeing memory are typical things it should
+   do.  */
+/* Close out all files and local state before this target loses control. */
+
+static void
+gdbbdm12_close (int quitting)
+{
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_close: quitting %d\n", quitting);
+
+  program_loaded = 0;
+
+  if (gdbbdm12_opened != 0)
+    {
+      bdm12_close (quitting);
+      gdbbdm12_opened = 0;
+    }
+
+  generic_mourn_inferior ();
+}
+
+/* Takes a program previously attached to and detaches it.
+   The program may resume execution (some targets do, some don't) and will
+   no longer stop on signals, etc.  We better not have left any breakpoints
+   in the program or it'll die when it hits one.  ARGS is arguments
+   typed by the user (e.g. a signal to send the process).  FROM_TTY
+   says whether to be verbose or not.  */
+/* Terminate the open connection to the remote debugger.
+   Use this when you want to detach and do something else with your gdb.  */
+
+static void
+gdbbdm12_detach (char *args, int from_tty)
+{
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_detach: args \"%s\"\n", args);
+
+  pop_target ();  /* calls gdbbdm12_close to do the real work */
+  if (from_tty)
+    printf_filtered ("Ending %s debugging\n", target_shortname);
+}
+
+/* Resume execution of the target process.  STEP says whether to single-step
+   or to run free; SIGGNAL is the signal value (e.g. SIGINT) to be given
+   to the target, or zero for no signal.  */
+
+static enum target_signal resume_siggnal;
+static int resume_step;
+
+static void
+gdbbdm12_resume (ptid_t pid, int step, enum target_signal siggnal)
+{
+  if (PIDGET (inferior_ptid) != 42)
+    error ("The program is not being run.");
+
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_resume: step %d, signal %d\n", step, siggnal);
+
+  resume_siggnal = siggnal;
+  resume_step = step;
+}
+
+/* Notify the bdm12 interface of an asynchronous request to stop. */
+
+static void
+gdbbdm12_stop (void)
+{
+  bdm12_stop_requested = 0;
+  if (!bdm12_stop ())
+    {
+      quit ();
+    }
+}
+
+static void
+gdbbdm12_cntrl_c (int signo)
+{
+  bdm12_stop_requested = 1;
+}
+
+/* Wait for inferior process to do something.  Return pid of child,
+   or -1 in case of error; store status through argument pointer STATUS,
+   just as `wait' would. */
+
+static ptid_t
+gdbbdm12_wait (ptid_t pid, struct target_waitstatus *status)
+{
+  static RETSIGTYPE (*prev_sigint) ();
+  int sigrc = 0;
+  enum bdm12_stop reason;
+
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_wait\n");
+
+#if defined (HAVE_SIGACTION) && defined (SA_RESTART)
+  {
+    struct sigaction sa, osa;
+    sa.sa_handler = gdbbdm12_cntrl_c;
+    sigemptyset (&sa.sa_mask);
+    sa.sa_flags = 0;
+    sigaction (SIGINT, &sa, &osa);
+    prev_sigint = osa.sa_handler;
+  }
+#else
+  prev_sigint = signal (SIGINT, gdbbdm12_cntrl_c);
+#endif
+  
+  bdm12_resume (resume_step);
+
+  do
+    bdm12_stop_reason (&reason, &sigrc);
+  while ((reason == BDM12_RUNNING) && !bdm12_stop_requested);
+
+  if (bdm12_stop_requested)
+    gdbbdm12_stop ();
+
+  signal (SIGINT, prev_sigint);
+  resume_step = 0;
+
+  switch (reason)
+    {
+    case BDM12_EXITED:
+      status->kind = TARGET_WAITKIND_EXITED;
+      status->value.integer = sigrc;
+      break;
+    case BDM12_STOPPED:
+      switch (sigrc)
+        {
+        case TARGET_SIGNAL_ABRT:
+          quit ();
+          break;
+        case TARGET_SIGNAL_INT:
+        case TARGET_SIGNAL_TRAP:
+        default:
+          status->kind = TARGET_WAITKIND_STOPPED;
+          status->value.sig = sigrc;
+          break;
+        }
+      break;
+    case BDM12_SIGNALLED:
+      status->kind = TARGET_WAITKIND_SIGNALLED;
+      status->value.sig = sigrc;
+      break;
+    case BDM12_RUNNING:
+    case BDM12_POLLING:
+      /* FIXME: Is this correct? */
+      break;
+    }
+
+  return inferior_ptid;
+}
+
+/* Get ready to modify the registers array.  On machines which store
+   individual registers, this doesn't need to do anything.  On machines
+   which store all the registers in one fell swoop, this makes sure
+   that registers contains all the registers from the program being
+   debugged.  */
+
+static void
+gdbbdm12_prepare_to_store (void)
+{
+  /* Do nothing, since we can store individual regs */
+}
+
+/* Transfer LEN bytes between GDB address MYADDR and target address
+   MEMADDR.  If WRITE is non-zero, transfer them to the target,
+   otherwise transfer them from the target.  TARGET is unused.
+
+   Returns the number of bytes transferred. */
+
+static int
+gdbbdm12_xfer_inferior_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
+                               int write, 
+                               struct mem_attrib *attrib ATTRIBUTE_UNUSED,
+                               struct target_ops *target ATTRIBUTE_UNUSED)
+{
+  if (sr_get_debug ())
+    {
+      /* FIXME: Send to something other than STDOUT? */
+      printf_filtered ("gdbbdm12_xfer_inferior_memory: myaddr 0x");
+      gdb_print_host_address (myaddr, gdb_stdout);
+      printf_filtered (", memaddr 0x%s, len %d, write %d\n",
+                       paddr_nz (memaddr), len, write);
+      if (sr_get_debug () && write)
+        dump_mem (myaddr, len);
+    }
+
+  if (write)
+    {
+      len = bdm12_write (memaddr, myaddr, len);
+    }
+  else
+    {
+      len = bdm12_read (memaddr, myaddr, len);
+      if (sr_get_debug () && len > 0)
+        dump_mem (myaddr, len);
+    }
+  return len;
+}
+
+static void
+gdbbdm12_files_info (struct target_ops *target)
+{
+  char *file = "nothing";
+
+  if (exec_bfd)
+    file = bfd_get_filename (exec_bfd);
+
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_files_info: file \"%s\"\n", file);
+
+  if (exec_bfd)
+    {
+      printf_filtered ("\tAttached to %s running program %s\n",
+                       target_shortname, file);
+    }
+}
+
+/* Clear the BDM interface's notion of what the breakpoints are.  */
+
+static void
+gdbbdm12_mourn_inferior (void)
+{
+  if (sr_get_debug ())
+    printf_filtered ("gdbbdm12_mourn_inferior:\n");
+
+  remove_breakpoints ();
+  generic_mourn_inferior ();
+}
+
+static int
+gdbbdm12_insert_breakpoint (CORE_ADDR addr, gdb_byte *contents_cache)
+{
+  BDM12_RC retcode;
+
+  retcode = bdm12_set_breakpoint (addr);
+
+  switch (retcode)
+    {
+    case BDM12_RC_OK:
+      return 0;
+    case BDM12_RC_INSUFFICIENT_RESOURCES:
+      return ENOMEM;
+    default:
+      return EIO;
+    }
+}
+
+static int
+gdbbdm12_remove_breakpoint (CORE_ADDR addr, gdb_byte *contents_cache)
+{
+  BDM12_RC retcode;
+
+  retcode = bdm12_clear_breakpoint (addr);
+
+  switch (retcode)
+    {
+    case BDM12_RC_OK:
+    case BDM12_RC_UNKNOWN_BREAKPOINT:
+      return 0;
+    case BDM12_RC_INSUFFICIENT_RESOURCES:
+      return ENOMEM;
+    default:
+      return EIO;
+    }
+}
+
+/* Pass the command argument through to the bdm12 interface verbatim.  The
+   bdm12 must do any command interpretation work.  */
+
+void
+pass_command (char *args, int from_tty)
+{
+  if (gdbbdm12_opened == 0)
+    {
+      /* Don't send commands if the interface isn't opened! */
+      error ("Not connected to the bdm12 interface");
+    }
+
+#if 0
+  /* implement later */ 
+  bdm12_do_command (args);
+#endif
+
+  /* Invalidate the register cache, in case the command does
+     something funny. */
+  registers_changed ();
+}
+
+/* Define the target subroutine names */
+
+struct target_ops gdbbdm12_ops;
+
+static void
+init_gdbbdm12_ops (void)
+{
+  gdbbdm12_ops.to_shortname = "bdm12";
+  gdbbdm12_ops.to_longname = "Kevin Ross' BDM12 Pod for BDM on the 68HC12";
+  gdbbdm12_ops.to_doc = "Debug using Kevin Ross' BDM12 Pod\n\
+(http://www.nwlink.com/~kevinro/bdm.html) for the Motorola 68HC12 series of\n\
+microcontrollers. This processor features a single wire background debug mode\n\
+interface.\n\
+Usage: target bdm12 <serial_device> <E-clock rate (1,2,4, or 8 MHz) \n\
+                    <register base> <ram base> <eeprom base> <flash base> \n\
+(ex. target bdm12 com1 8 0x0 0x800 0xd00 0x8000 on Win32, \n\
+  or target bdm12 ttya 8 0x0 0x800 0xd00 0x8000 on UNIX)";
+  gdbbdm12_ops.to_open = gdbbdm12_open;
+  gdbbdm12_ops.to_close = gdbbdm12_close;
+  gdbbdm12_ops.to_attach = NULL;
+  gdbbdm12_ops.to_post_attach = NULL;
+  gdbbdm12_ops.to_detach = gdbbdm12_detach;
+  gdbbdm12_ops.to_resume = gdbbdm12_resume;
+  gdbbdm12_ops.to_wait = gdbbdm12_wait;
+  gdbbdm12_ops.to_fetch_registers = gdbbdm12_fetch_register;
+  gdbbdm12_ops.to_store_registers = gdbbdm12_store_register;
+  gdbbdm12_ops.to_prepare_to_store = gdbbdm12_prepare_to_store;
+  gdbbdm12_ops.deprecated_xfer_memory = gdbbdm12_xfer_inferior_memory;
+  gdbbdm12_ops.to_files_info = gdbbdm12_files_info;
+  gdbbdm12_ops.to_insert_breakpoint = gdbbdm12_insert_breakpoint;
+  gdbbdm12_ops.to_remove_breakpoint = gdbbdm12_remove_breakpoint;
+  gdbbdm12_ops.to_terminal_init = NULL;
+  gdbbdm12_ops.to_terminal_inferior = NULL;
+  gdbbdm12_ops.to_terminal_ours_for_output = NULL;
+  gdbbdm12_ops.to_terminal_ours = NULL;
+  gdbbdm12_ops.to_terminal_info = NULL;
+  gdbbdm12_ops.to_kill = gdbbdm12_kill;
+  gdbbdm12_ops.to_load = gdbbdm12_load;
+  gdbbdm12_ops.to_lookup_symbol = NULL;
+  gdbbdm12_ops.to_create_inferior = gdbbdm12_create_inferior;
+  gdbbdm12_ops.to_post_startup_inferior = NULL;
+  gdbbdm12_ops.to_acknowledge_created_inferior = NULL;
+  gdbbdm12_ops.to_insert_fork_catchpoint = NULL;
+  gdbbdm12_ops.to_remove_fork_catchpoint = NULL;
+  gdbbdm12_ops.to_insert_vfork_catchpoint = NULL;
+  gdbbdm12_ops.to_remove_vfork_catchpoint = NULL;
+  gdbbdm12_ops.to_insert_exec_catchpoint = NULL;
+  gdbbdm12_ops.to_remove_exec_catchpoint = NULL;
+  gdbbdm12_ops.to_reported_exec_events_per_exec_call = NULL;
+  gdbbdm12_ops.to_has_exited = NULL;
+  gdbbdm12_ops.to_mourn_inferior = gdbbdm12_mourn_inferior;
+  gdbbdm12_ops.to_can_run = 0;
+  gdbbdm12_ops.to_notice_signals = 0;
+  gdbbdm12_ops.to_thread_alive = 0;
+  gdbbdm12_ops.to_stop = gdbbdm12_stop;
+  gdbbdm12_ops.to_pid_to_exec_file = NULL;
+  gdbbdm12_ops.to_stratum = process_stratum;
+  gdbbdm12_ops.to_has_all_memory = 1;
+  gdbbdm12_ops.to_has_memory = 1;
+  gdbbdm12_ops.to_has_stack = 1;
+  gdbbdm12_ops.to_has_registers = 1;
+  gdbbdm12_ops.to_has_execution = 1;
+  gdbbdm12_ops.to_sections = NULL;
+  gdbbdm12_ops.to_sections_end = NULL;
+  gdbbdm12_ops.to_magic = OPS_MAGIC;
+
+#ifdef TARGET_REDEFINE_DEFAULT_OPS
+  TARGET_REDEFINE_DEFAULT_OPS (&gdbbdm12_ops);
+#endif
+}
+
+
+void
+_initialize_remote_bdm12 (void)
+{
+  init_gdbbdm12_ops ();
+  add_target (&gdbbdm12_ops);
+
+  add_com ("bdm12 <command>", class_obscure, pass_command,
+           "Send a command to the BDM interface directly.");
+}
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/ser-dummy.c gdb-6.4-m68hc1x/gdb/ser-dummy.c
--- gdb-6.4/gdb/ser-dummy.c	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/ser-dummy.c	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,153 @@
+/* Dummy (do-nothing) serial interface */
+
+/*
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "serial.h"
+
+static int
+ser_dummy_open (struct serial *scb ATTRIBUTE_UNUSED, const char *name ATTRIBUTE_UNUSED)
+{
+  scb->fd = -1;
+  return 0;
+}
+
+void
+ser_dummy_close (struct serial *scb ATTRIBUTE_UNUSED)
+{
+}
+
+/* Wait for the output to drain away, as opposed to flushing (discarding) it */
+
+serial_ttystate
+ser_dummy_get_tty_state (struct serial *scb ATTRIBUTE_UNUSED)
+{
+  /* allocate a dummy */
+  return (serial_ttystate) xmalloc (8);
+}
+
+int
+ser_dummy_set_tty_state (struct serial *scb ATTRIBUTE_UNUSED, serial_ttystate ttystate ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+void
+ser_dummy_go_raw (struct serial *scb ATTRIBUTE_UNUSED)
+{
+  return;			/* Always in raw mode */
+}
+
+
+int
+ser_dummy_readchar (struct serial *scb ATTRIBUTE_UNUSED, int timeout ATTRIBUTE_UNUSED)
+{
+  return SERIAL_EOF;
+}
+
+int
+ser_dummy_noflush_set_tty_state (struct serial *scb ATTRIBUTE_UNUSED,
+				    serial_ttystate new_ttystate ATTRIBUTE_UNUSED,
+				    serial_ttystate old_ttystate ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+void
+ser_dummy_print_tty_state (struct serial *scb ATTRIBUTE_UNUSED, 
+			      serial_ttystate ttystate ATTRIBUTE_UNUSED,
+			      struct ui_file *stream ATTRIBUTE_UNUSED)
+{
+  /* Nothing to print.  */
+  return;
+}
+
+int
+ser_dummy_setbaudrate (struct serial *scb ATTRIBUTE_UNUSED, int rate ATTRIBUTE_UNUSED)
+{
+  return 0;			/* Never fails! */
+}
+
+int
+ser_dummy_setstopbits (struct serial *scb ATTRIBUTE_UNUSED, int num ATTRIBUTE_UNUSED)
+{
+  return 0;			/* Never fails! */
+}
+
+int
+ser_dummy_write (struct serial *scb ATTRIBUTE_UNUSED, const char *str ATTRIBUTE_UNUSED, int len ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+int
+ser_dummy_flush_output (struct serial *scb ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+int
+ser_dummy_flush_input (struct serial *scb ATTRIBUTE_UNUSED)
+{
+ return 0;
+}
+
+int
+ser_dummy_send_break (struct serial *scb ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+static int
+ser_dummy_drain_output (struct serial *scb ATTRIBUTE_UNUSED)
+{
+  return 0;
+}
+
+/* Put the SERIAL device into/out-of ASYNC mode.  */
+
+void
+ser_dummy_async (struct serial *scb ATTRIBUTE_UNUSED,
+		int async_p ATTRIBUTE_UNUSED)
+{
+}
+
+void
+_initialize_dummy_ser_hardwire (void)
+{
+  struct serial_ops *ops = (struct serial_ops *) xmalloc (sizeof (struct serial_ops));
+  memset (ops, sizeof (struct serial_ops), 0);
+  ops->name = "hardwire";
+  ops->next = 0;
+  ops->open = ser_dummy_open;
+  ops->close = ser_dummy_close;
+  ops->readchar = ser_dummy_readchar;
+  ops->write = ser_dummy_write;
+  ops->flush_output = ser_dummy_flush_output;
+  ops->flush_input = ser_dummy_flush_input;
+  ops->send_break = ser_dummy_send_break;
+  ops->go_raw = ser_dummy_go_raw;
+  ops->get_tty_state = ser_dummy_get_tty_state;
+  ops->set_tty_state = ser_dummy_set_tty_state;
+  ops->print_tty_state = ser_dummy_print_tty_state;
+  ops->noflush_set_tty_state = ser_dummy_noflush_set_tty_state;
+  ops->setbaudrate = ser_dummy_setbaudrate;
+  ops->setstopbits = ser_dummy_setstopbits;
+  ops->drain_output = ser_dummy_drain_output;
+  ops->async = ser_dummy_async;
+  serial_add_interface (ops);
+}
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/ser-mingw.c gdb-6.4-m68hc1x/gdb/ser-mingw.c
--- gdb-6.4/gdb/ser-mingw.c	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/ser-mingw.c	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,533 @@
+/* Serial interface for TCP connections on MingW Windows systems
+   Copyright 1992, 1993, 1994, 1995, 1996, 1998, 1999, 2000, 2001
+   Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#include "defs.h"
+#include "serial.h"
+#include "ser-mingw.h"
+
+#include <fcntl.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+
+#include <winsock2.h>
+
+#include "gdb_string.h"
+#include "event-loop.h"
+
+void
+gettimeofday(struct timeval* tv, struct timezone* tz)
+{
+  struct timeb tb;
+
+  ftime(&tb);
+  tv->tv_sec = (unsigned long) tb.time;
+  tv->tv_usec = ((unsigned long) tb.millitm) * 1000L;
+}
+
+static int do_mingw_readchar (struct serial *scb, int timeout);
+static timer_handler_func push_event;
+static handler_func fd_event;
+static void reschedule (struct serial *scb);
+
+extern int (*deprecated_ui_loop_hook) (int);
+
+/* Generic operations used by all UNIX/FD based serial interfaces. */
+
+serial_ttystate
+ser_mingw_nop_get_tty_state (struct serial *scb)
+{
+  /* allocate a dummy */
+  return (serial_ttystate) XMALLOC (int);
+}
+
+int
+ser_mingw_nop_set_tty_state (struct serial *scb, serial_ttystate ttystate)
+{
+  return 0;
+}
+
+void
+ser_mingw_nop_raw (struct serial *scb)
+{
+  return;			/* Always in raw mode */
+}
+
+/* Wait for input on scb, with timeout seconds.  Returns 0 on success,
+   otherwise SERIAL_TIMEOUT or SERIAL_ERROR. */
+
+int
+ser_mingw_wait_for (struct serial *scb, int timeout)
+{
+  while (1)
+    {
+      int numfds;
+      struct timeval tv;
+      fd_set readfds, exceptfds;
+
+      /* NOTE: Some OS's can scramble the READFDS when the select()
+         call fails (ex the kernel with Red Hat 5.2).  Initialize all
+         arguments before each call. */
+
+      tv.tv_sec = timeout;
+      tv.tv_usec = 0;
+
+      FD_ZERO (&readfds);
+      FD_ZERO (&exceptfds);
+      FD_SET (scb->fd, &readfds);
+      FD_SET (scb->fd, &exceptfds);
+
+      if (timeout >= 0)
+	numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, &tv);
+      else
+	numfds = select (scb->fd + 1, &readfds, 0, &exceptfds, 0);
+
+      if (numfds <= 0)
+	{
+	  if (numfds == 0)
+	    return SERIAL_TIMEOUT;
+	  else if (errno == EINTR)
+	    continue;
+	  else
+	    return SERIAL_ERROR;	/* Got an error from select or poll */
+	}
+
+      return 0;
+    }
+}
+
+/* Read a character with user-specified timeout.  TIMEOUT is number of seconds
+   to wait, or -1 to wait forever.  Use timeout of 0 to effect a poll.  Returns
+   char if successful.  Returns -2 if timeout expired, EOF if line dropped
+   dead, or -3 for any other error (see errno in that case). */
+
+static int
+do_mingw_readchar (struct serial *scb, int timeout)
+{
+  int status;
+  int delta;
+
+  /* We have to be able to keep the GUI alive here, so we break the original
+     timeout into steps of 1 second, running the "keep the GUI alive" hook 
+     each time through the loop.
+
+     Also, timeout = 0 means to poll, so we just set the delta to 0, so we
+     will only go through the loop once. */
+
+  delta = (timeout == 0 ? 0 : 1);
+  while (1)
+    {
+
+      /* N.B. The UI may destroy our world (for instance by calling
+         remote_stop,) in which case we want to get out of here as
+         quickly as possible.  It is not safe to touch scb, since
+         someone else might have freed it.  The ui_loop_hook signals that 
+         we should exit by returning 1. */
+
+      if (deprecated_ui_loop_hook)
+	{
+	  if (deprecated_ui_loop_hook (0))
+	    return SERIAL_TIMEOUT;
+	}
+
+      status = ser_mingw_wait_for (scb, delta);
+      if (timeout > 0)
+        timeout -= delta;
+
+      /* If we got a character or an error back from wait_for, then we can 
+         break from the loop before the timeout is completed. */
+
+      if (status != SERIAL_TIMEOUT)
+	{
+	  break;
+	}
+
+      /* If we have exhausted the original timeout, then generate
+         a SERIAL_TIMEOUT, and pass it out of the loop. */
+
+      else if (timeout == 0)
+	{
+	  status = SERIAL_TIMEOUT;
+	  break;
+	}
+    }
+
+  if (status < 0)
+    return status;
+
+  while (1)
+    {
+      status = recv (scb->fd, scb->buf, BUFSIZ, 0);
+      if (status != -1 || errno != EINTR)
+	break;
+    }
+
+  if (status <= 0)
+    {
+      if (status == 0)
+	return SERIAL_TIMEOUT;	/* 0 chars means timeout [may need to
+				   distinguish between EOF & timeouts
+				   someday] */
+      else
+	return SERIAL_ERROR;	/* Got an error from read */
+    }
+
+  scb->bufcnt = status;
+  scb->bufcnt--;
+  scb->bufp = scb->buf;
+  return *scb->bufp++;
+}
+
+/* Perform operations common to both old and new readchar. */
+
+/* Return the next character from the input FIFO.  If the FIFO is
+   empty, call the SERIAL specific routine to try and read in more
+   characters.
+
+   Initially data from the input FIFO is returned (fd_event()
+   pre-reads the input into that FIFO.  Once that has been emptied,
+   further data is obtained by polling the input FD using the device
+   specific readchar() function.  Note: reschedule() is called after
+   every read.  This is because there is no guarentee that the lower
+   level fd_event() poll_event() code (which also calls reschedule())
+   will be called. */
+
+static int
+generic_readchar (struct serial *scb, int timeout,
+		  int (do_readchar) (struct serial *scb, int timeout))
+{
+  int ch;
+  if (scb->bufcnt > 0)
+    {
+      ch = *scb->bufp;
+      scb->bufcnt--;
+      scb->bufp++;
+    }
+  else if (scb->bufcnt < 0)
+    {
+      /* Some errors/eof are are sticky. */
+      ch = scb->bufcnt;
+    }
+  else
+    {
+      ch = do_readchar (scb, timeout);
+      if (ch < 0)
+	{
+	  switch ((enum serial_rc) ch)
+	    {
+	    case SERIAL_EOF:
+	    case SERIAL_ERROR:
+	      /* Make the error/eof stick. */
+	      scb->bufcnt = ch;
+	      break;
+	    case SERIAL_TIMEOUT:
+	      scb->bufcnt = 0;
+	      break;
+	    }
+	}
+    }
+  reschedule (scb);
+  return ch;
+}
+
+int
+ser_mingw_readchar (struct serial *scb, int timeout)
+{
+  return generic_readchar (scb, timeout, do_mingw_readchar);
+}
+
+int
+ser_mingw_nop_noflush_set_tty_state (struct serial *scb,
+				    serial_ttystate new_ttystate,
+				    serial_ttystate old_ttystate)
+{
+  return 0;
+}
+
+void
+ser_mingw_nop_print_tty_state (struct serial *scb, 
+			      serial_ttystate ttystate,
+			      struct ui_file *stream)
+{
+  /* Nothing to print.  */
+  return;
+}
+
+int
+ser_mingw_nop_setbaudrate (struct serial *scb, int rate)
+{
+  return 0;			/* Never fails! */
+}
+
+int
+ser_mingw_nop_setstopbits (struct serial *scb, int num)
+{
+  return 0;			/* Never fails! */
+}
+
+int
+ser_mingw_write (struct serial *scb, const char *str, int len)
+{
+  int cc;
+
+  while (len > 0)
+    {
+      cc = send (scb->fd, str, len, 0);
+
+      if (cc < 0)
+	return 1;
+      len -= cc;
+      str += cc;
+    }
+  return 0;
+}
+
+int
+ser_mingw_nop_flush_output (struct serial *scb)
+{
+  return 0;
+}
+
+int
+ser_mingw_flush_input (struct serial *scb)
+{
+  if (scb->bufcnt >= 0)
+    {
+      scb->bufcnt = 0;
+      scb->bufp = scb->buf;
+      return 0;
+    }
+  else
+    return SERIAL_ERROR;
+}
+
+int
+ser_mingw_nop_send_break (struct serial *scb)
+{
+  return 0;
+}
+
+int
+ser_mingw_nop_drain_output (struct serial *scb)
+{
+  return 0;
+}
+
+
+
+/* Event handling for ASYNC serial code.
+
+   At any time the SERIAL device either: has an empty FIFO and is
+   waiting on a FD event; or has a non-empty FIFO/error condition and
+   is constantly scheduling timer events.
+
+   ASYNC only stops pestering its client when it is de-async'ed or it
+   is told to go away. */
+
+/* Value of scb->async_state: */
+enum {
+  /* >= 0 (TIMER_SCHEDULED) */
+  /* The ID of the currently scheduled timer event. This state is
+     rarely encountered.  Timer events are one-off so as soon as the
+     event is delivered the state is shanged to NOTHING_SCHEDULED. */
+  FD_SCHEDULED = -1,
+  /* The fd_event() handler is scheduled.  It is called when ever the
+     file descriptor becomes ready. */
+  NOTHING_SCHEDULED = -2
+  /* Either no task is scheduled (just going into ASYNC mode) or a
+     timer event has just gone off and the current state has been
+     forced into nothing scheduled. */
+};
+
+/* Identify and schedule the next ASYNC task based on scb->async_state
+   and scb->buf* (the input FIFO).  A state machine is used to avoid
+   the need to make redundant calls into the event-loop - the next
+   scheduled task is only changed when needed. */
+
+static void
+reschedule (struct serial *scb)
+{
+  if (serial_is_async_p (scb))
+    {
+      int next_state;
+      switch (scb->async_state)
+	{
+	case FD_SCHEDULED:
+	  if (scb->bufcnt == 0)
+	    next_state = FD_SCHEDULED;
+	  else
+	    {
+	      delete_file_handler (scb->fd);
+	      next_state = create_timer (0, push_event, scb);
+	    }
+	  break;
+	case NOTHING_SCHEDULED:
+	  if (scb->bufcnt == 0)
+	    {
+	      add_file_handler (scb->fd, fd_event, scb);
+	      next_state = FD_SCHEDULED;
+	    }
+	  else
+	    {
+	      next_state = create_timer (0, push_event, scb);
+	    }
+	  break;
+	default: /* TIMER SCHEDULED */
+	  if (scb->bufcnt == 0)
+	    {
+	      delete_timer (scb->async_state);
+	      add_file_handler (scb->fd, fd_event, scb);
+	      next_state = FD_SCHEDULED;
+	    }
+	  else
+	    next_state = scb->async_state;
+	  break;
+	}
+      if (serial_debug_p (scb))
+	{
+	  switch (next_state)
+	    {
+	    case FD_SCHEDULED:
+	      if (scb->async_state != FD_SCHEDULED)
+		fprintf_unfiltered (gdb_stdlog, "[fd%d->fd-scheduled]\n",
+				    scb->fd);
+	      break;
+	    default: /* TIMER SCHEDULED */
+	      if (scb->async_state == FD_SCHEDULED)
+		fprintf_unfiltered (gdb_stdlog, "[fd%d->timer-scheduled]\n",
+				    scb->fd);
+	      break;
+	    }
+	}
+      scb->async_state = next_state;
+    }
+}
+
+/* FD_EVENT: This is scheduled when the input FIFO is empty (and there
+   is no pending error).  As soon as data arrives, it is read into the
+   input FIFO and the client notified.  The client should then drain
+   the FIFO using readchar().  If the FIFO isn't immediatly emptied,
+   push_event() is used to nag the client until it is. */
+
+static void
+fd_event (int error, void *context)
+{
+  struct serial *scb = context;
+  if (error != 0)
+    {
+      scb->bufcnt = SERIAL_ERROR;
+    }
+  else if (scb->bufcnt == 0)
+    {
+      /* Prime the input FIFO.  The readchar() function is used to
+         pull characters out of the buffer.  See also
+         generic_readchar(). */
+      int nr;
+      do
+	{
+	  nr = read (scb->fd, scb->buf, BUFSIZ);
+	}
+      while (nr == -1 && errno == EINTR);
+      if (nr == 0)
+	{
+	  scb->bufcnt = SERIAL_EOF;
+	}
+      else if (nr > 0)
+	{
+	  scb->bufcnt = nr;
+	  scb->bufp = scb->buf;
+	}
+      else
+	{
+	  scb->bufcnt = SERIAL_ERROR;
+	}
+    }
+  scb->async_handler (scb, scb->async_context);
+  reschedule (scb);
+}
+
+/* PUSH_EVENT: The input FIFO is non-empty (or there is a pending
+   error).  Nag the client until all the data has been read.  In the
+   case of errors, the client will need to close or de-async the
+   device before naging stops. */
+
+static void
+push_event (void *context)
+{
+  struct serial *scb = context;
+  scb->async_state = NOTHING_SCHEDULED; /* Timers are one-off */
+  scb->async_handler (scb, scb->async_context);
+  /* re-schedule */
+  reschedule (scb);
+}
+
+/* Put the SERIAL device into/out-of ASYNC mode.  */
+
+void
+ser_mingw_async (struct serial *scb,
+		int async_p)
+{
+  if (async_p)
+    {
+      /* Force a re-schedule. */
+      scb->async_state = NOTHING_SCHEDULED;
+      if (serial_debug_p (scb))
+	fprintf_unfiltered (gdb_stdlog, "[fd%d->asynchronous]\n",
+			    scb->fd);
+      reschedule (scb);
+    }
+  else
+    {
+      if (serial_debug_p (scb))
+	fprintf_unfiltered (gdb_stdlog, "[fd%d->synchronous]\n",
+			    scb->fd);
+      /* De-schedule whatever tasks are currently scheduled. */
+      switch (scb->async_state)
+	{
+	case FD_SCHEDULED:
+	  delete_file_handler (scb->fd);
+	  break;
+	NOTHING_SCHEDULED:
+	  break;
+	default: /* TIMER SCHEDULED */
+	  delete_timer (scb->async_state);
+	  break;
+	}
+    }
+}
+
+void
+ser_platform_tcp_init (struct serial_ops *ops)
+{
+  ops->readchar = ser_mingw_readchar;
+  ops->write = ser_mingw_write;
+  ops->flush_output = ser_mingw_nop_flush_output;
+  ops->flush_input = ser_mingw_flush_input;
+  ops->send_break = ser_mingw_nop_send_break;
+  ops->go_raw = ser_mingw_nop_raw;
+  ops->get_tty_state = ser_mingw_nop_get_tty_state;
+  ops->set_tty_state = ser_mingw_nop_set_tty_state;
+  ops->print_tty_state = ser_mingw_nop_print_tty_state;
+  ops->noflush_set_tty_state = ser_mingw_nop_noflush_set_tty_state;
+  ops->setbaudrate = ser_mingw_nop_setbaudrate;
+  ops->setstopbits = ser_mingw_nop_setstopbits;
+  ops->drain_output = ser_mingw_nop_drain_output;
+  ops->async = ser_mingw_async;
+}
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/ser-mingw.h gdb-6.4-m68hc1x/gdb/ser-mingw.h
--- gdb-6.4/gdb/ser-mingw.h	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/ser-mingw.h	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,51 @@
+/* Serial interface for MinGW Winsock file-descriptor based connection.
+
+   Copyright 1999, 2000, 2002 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#ifndef SER_MINGW_H
+#define SER_MINGW_H
+
+/* Generic MinGW Winsock functions */
+
+extern int ser_mingw_nop_flush_output (struct serial *scb);
+extern int ser_mingw_flush_input (struct serial *scb);
+extern int ser_mingw_nop_send_break (struct serial *scb);
+extern void ser_mingw_nop_raw (struct serial *scb);
+extern serial_ttystate ser_mingw_nop_get_tty_state (struct serial *scb);
+extern int ser_mingw_nop_set_tty_state (struct serial *scb,
+				       serial_ttystate ttystate);
+extern void ser_mingw_nop_print_tty_state (struct serial *scb,
+					  serial_ttystate ttystate,
+					  struct ui_file *stream);
+extern int ser_mingw_nop_noflush_set_tty_state (struct serial *scb,
+					       serial_ttystate new_ttystate,
+					       serial_ttystate old_ttystate);
+extern int ser_mingw_nop_setbaudrate (struct serial *scb, int rate);
+extern int ser_mingw_nop_setstopbits (struct serial *scb, int rate);
+extern int ser_mingw_nop_drain_output (struct serial *scb);
+
+extern int ser_mingw_wait_for (struct serial *scb, int timeout);
+extern int ser_mingw_readchar (struct serial *scb, int timeout);
+
+extern int ser_mingw_write (struct serial *scb, const char *str, int len);
+
+extern void ser_mingw_async (struct serial *scb, int async_p);
+
+#endif
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/serial.c gdb-6.4-m68hc1x/gdb/serial.c
--- gdb-6.4/gdb/serial.c	Mon Feb 21 05:31:58 2005
+++ gdb-6.4-m68hc1x/gdb/serial.c	Sat Jan 21 15:28:49 2006
@@ -329,12 +329,16 @@ do_serial_close (struct serial *scb, int
 void
 serial_close (struct serial *scb)
 {
+  if (!scb)
+    return;
   do_serial_close (scb, 1);
 }
 
 void
 serial_un_fdopen (struct serial *scb)
 {
+  if (!scb)
+    return;
   do_serial_close (scb, 0);
 }
 
@@ -343,6 +347,9 @@ serial_readchar (struct serial *scb, int
 {
   int ch;
 
+  if (!scb)
+    return 0;
+
   /* FIXME: cagney/1999-10-11: Don't enable this check until the ASYNC
      code is finished. */
   if (0 && serial_is_async_p (scb) && timeout < 0)
@@ -384,6 +391,9 @@ serial_write (struct serial *scb, const 
       gdb_flush (serial_logfp);
     }
 
+  if (!scb)
+    return 0;
+
   return (scb->ops->write (scb, str, len));
 }
 
@@ -404,24 +414,33 @@ serial_printf (struct serial *desc, cons
 int
 serial_drain_output (struct serial *scb)
 {
+  if (!scb)
+    return 0;
   return scb->ops->drain_output (scb);
 }
 
 int
 serial_flush_output (struct serial *scb)
 {
+  if (!scb)
+    return 0;
   return scb->ops->flush_output (scb);
 }
 
 int
 serial_flush_input (struct serial *scb)
 {
+  if (!scb)
+    return 0;
   return scb->ops->flush_input (scb);
 }
 
 int
 serial_send_break (struct serial *scb)
 {
+  if (!scb)
+    return 0;
+
   if (serial_logfp != NULL)
     serial_logchar (serial_logfp, 'w', SERIAL_BREAK, 0);
 
@@ -431,18 +450,24 @@ serial_send_break (struct serial *scb)
 void
 serial_raw (struct serial *scb)
 {
+  if (!scb)
+    return;
   scb->ops->go_raw (scb);
 }
 
 serial_ttystate
 serial_get_tty_state (struct serial *scb)
 {
+  if (!scb)
+    return 0;
   return scb->ops->get_tty_state (scb);
 }
 
 int
 serial_set_tty_state (struct serial *scb, serial_ttystate ttystate)
 {
+  if (!scb)
+    return 0;
   return scb->ops->set_tty_state (scb, ttystate);
 }
 
@@ -451,6 +476,8 @@ serial_print_tty_state (struct serial *s
 			serial_ttystate ttystate,
 			struct ui_file *stream)
 {
+  if (!scb)
+    return;
   scb->ops->print_tty_state (scb, ttystate, stream);
 }
 
@@ -459,30 +486,40 @@ serial_noflush_set_tty_state (struct ser
 			      serial_ttystate new_ttystate,
 			      serial_ttystate old_ttystate)
 {
+  if (!scb)
+    return 0;
   return scb->ops->noflush_set_tty_state (scb, new_ttystate, old_ttystate);
 }
 
 int
 serial_setbaudrate (struct serial *scb, int rate)
 {
+  if (!scb)
+    return 0;
   return scb->ops->setbaudrate (scb, rate);
 }
 
 int
 serial_setstopbits (struct serial *scb, int num)
 {
+  if (!scb)
+    return 0;
   return scb->ops->setstopbits (scb, num);
 }
 
 int
 serial_can_async_p (struct serial *scb)
 {
+  if (!scb)
+    return 0;
   return (scb->ops->async != NULL);
 }
 
 int
 serial_is_async_p (struct serial *scb)
 {
+  if (!scb)
+    return 0;
   return (scb->ops->async != NULL) && (scb->async_handler != NULL);
 }
 
@@ -491,6 +528,9 @@ serial_async (struct serial *scb,
 	      serial_event_ftype *handler,
 	      void *context)
 {
+  if (!scb)
+    return;
+
   /* Only change mode if there is a need. */
   if ((scb->async_handler == NULL)
       != (handler == NULL))
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/signals/signals.c gdb-6.4-m68hc1x/gdb/signals/signals.c
--- gdb-6.4/gdb/signals/signals.c	Sun Jun  8 20:27:14 2003
+++ gdb-6.4-m68hc1x/gdb/signals/signals.c	Sat Jan 21 15:28:49 2006
@@ -44,6 +44,11 @@
 # endif
 #endif
 
+/* SCz: We need SIGTRAP for interaction with the gdb simulator  */
+#ifndef SIGTRAP
+# define SIGTRAP 5
+#endif
+
 /* This table must match in order and size the signals in enum target_signal
    in target.h.  */
 /* *INDENT-OFF* */
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/srec.h gdb-6.4-m68hc1x/gdb/srec.h
--- gdb-6.4/gdb/srec.h	Sat Apr 12 19:41:25 2003
+++ gdb-6.4-m68hc1x/gdb/srec.h	Sat Jan 21 15:28:49 2006
@@ -22,7 +22,8 @@ struct serial;
 
 void load_srec (struct serial *desc, const char *file, bfd_vma load_offset,
 		int maxrecsize, int flags, int hashmark,
-		int (*waitack) (void));
+		int (*waitack) (void),
+                int (*serial_write) (struct serial*, char*, int));
 
 /* S-record capability flags */
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/ChangeLog.M68HC11 gdb-6.4-m68hc1x/gdb/testsuite/ChangeLog.M68HC11
--- gdb-6.4/gdb/testsuite/ChangeLog.M68HC11	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/gdb/testsuite/ChangeLog.M68HC11	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,22 @@
+2002-11-13  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* gdb.base/huge.exp: Skip this test.
+	* gdb.fortran/types.exp: Likewise.
+	* gdb.fortran/exprs.exp: Don't run fortran float tests for 68HC11.
+
+2002-11-13  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* gdb.base/remote.exp: Compile remote.c with -mshort for 68HC11.
+	* gdb.base/printcmds.exp: Run the test after we are in the main.
+	* gdb.base/break.exp: Fix test because there is also a marker4()
+	at line 46.
+
+2002-08-12  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* gdb.trace/deltrace.exp: Don't fail if target does not support
+	trace points.
+	* gdb.trace/passcount.exp: Likewise.
+	* gdb.trace/save-trace.exp: Likewise.
+	* lib/gdb.exp: Don't run C++ test on 68HC11.
+	* gdb.threads/gcore-thread.exp: Don't run the test for 68HC11.
+	* gdb.asm/m68hc11.inc: New file.
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.base/huge.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.base/huge.exp
--- gdb-6.4/gdb/testsuite/gdb.base/huge.exp	Mon Feb  2 06:15:27 2004
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.base/huge.exp	Sat Jan 21 15:28:49 2006
@@ -32,7 +32,9 @@ set bug_id 0
 if [target_info exists gdb,skip_huge_test] {
     return;
 }
-
+if [istarget "m6811-*-*"] {
+    return;
+}
 set testfile "huge"
 set srcfile ${testfile}.c
 set binfile ${objdir}/${subdir}/${testfile}
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.base/printcmds.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.base/printcmds.exp
--- gdb-6.4/gdb/testsuite/gdb.base/printcmds.exp	Thu Feb 26 18:23:23 2004
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.base/printcmds.exp	Sat Jan 21 15:28:49 2006
@@ -694,9 +694,9 @@ gdb_test "set print address off" ""
 gdb_test "set width 0" ""
 
 if [set_lang_c] then {
-    gdb_test "p ctable1\[120\]" "120 'x'" "p ctable1\[120\] #1"
-
     if [runto_main] then {
+	gdb_test "p ctable1\[120\]" "120 'x'" "p ctable1\[120\] #1"
+
 	test_integer_literals_accepted
 	test_integer_literals_rejected
 	test_character_literals_accepted
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.base/remote.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.base/remote.exp
--- gdb-6.4/gdb/testsuite/gdb.base/remote.exp	Fri Sep 10 03:04:58 2004
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.base/remote.exp	Sat Jan 21 15:28:49 2006
@@ -36,7 +36,12 @@ set binfile ${objdir}/${subdir}/${testfi
 
 gdb_start
 
-set result [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}]
+# Must compile remote.c with 16-bit int
+if [istarget "m6811-*-*"] then {
+   set result [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug additional_flags=-mshort}]
+} else {
+   set result [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug}]
+}
 if {$result != "" } then {
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
 }
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.fortran/exprs.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.fortran/exprs.exp
--- gdb-6.4/gdb/testsuite/gdb.fortran/exprs.exp	Tue Sep 20 08:37:03 2005
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.fortran/exprs.exp	Sat Jan 21 15:28:49 2006
@@ -280,7 +280,9 @@ if [set_lang_fortran] then {
     test_integer_literals_rejected
     test_logical_literals_accepted
     test_character_literals_accepted
-    test_float_literals_accepted
+    if {! [istarget "m6811-*-*"]} {
+        test_float_literals_accepted
+    }
     test_arithmetic_expressions
 } else {
     warning "$test_name tests suppressed." 0
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.fortran/types.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.fortran/types.exp
--- gdb-6.4/gdb/testsuite/gdb.fortran/types.exp	Mon Dec 16 20:33:53 2002
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.fortran/types.exp	Sat Jan 21 15:28:49 2006
@@ -109,7 +109,9 @@ if [set_lang_fortran] then {
     test_integer_literal_types_rejected
     test_logical_literal_types_accepted
     test_character_literal_types_accepted
-    test_float_literal_types_accepted
+    if {! [istarget "m6811-*-*"]} {
+        test_float_literal_types_accepted
+    }
 } else {
     warning "$test_name tests suppressed." 0
 }
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.threads/gcore-thread.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.threads/gcore-thread.exp
--- gdb-6.4/gdb/testsuite/gdb.threads/gcore-thread.exp	Mon Feb  2 06:15:27 2004
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.threads/gcore-thread.exp	Sat Jan 21 15:28:49 2006
@@ -24,6 +24,11 @@ if $tracelevel then {
 	strace $tracelevel
 }
 
+# Threads are not supported for 68HC11.
+if [istarget "m6811-*-*"] then {
+    return;
+}
+
 set prms_id 0
 set bug_id 0
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.trace/deltrace.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.trace/deltrace.exp
--- gdb-6.4/gdb/testsuite/gdb.trace/deltrace.exp	Tue Apr 17 22:16:31 2001
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.trace/deltrace.exp	Sat Jan 21 15:28:49 2006
@@ -50,6 +50,15 @@ gdb_reinitialize_dir $srcdir/$subdir
 
 gdb_file_cmd $binfile
 
+
+# We generously give ourselves one "pass" if we successfully 
+# detect that this test cannot be run on this target!
+if { ![gdb_target_supports_trace] } then {
+    pass "Current target does not supporst trace"
+    return 1;
+
+}
+
 # define relative source line numbers:
 # all subsequent line numbers are relative to this first one (baseline)
 set baseline [gdb_find_recursion_test_baseline $srcfile];
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.trace/passcount.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.trace/passcount.exp
--- gdb-6.4/gdb/testsuite/gdb.trace/passcount.exp	Tue Apr 17 22:16:31 2001
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.trace/passcount.exp	Sat Jan 21 15:28:49 2006
@@ -49,6 +49,14 @@ gdb_reinitialize_dir $srcdir/$subdir
 
 gdb_file_cmd $binfile
 
+# We generously give ourselves one "pass" if we successfully 
+# detect that this test cannot be run on this target!
+if { ![gdb_target_supports_trace] } then {
+    pass "Current target does not supporst trace"
+    return 1;
+
+}
+
 # define relative source line numbers:
 # all subsequent line numbers are relative to this first one (baseline)
 set baseline  [gdb_find_recursion_test_baseline $srcfile];
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/gdb.trace/save-trace.exp gdb-6.4-m68hc1x/gdb/testsuite/gdb.trace/save-trace.exp
--- gdb-6.4/gdb/testsuite/gdb.trace/save-trace.exp	Thu Aug  7 19:55:41 2003
+++ gdb-6.4-m68hc1x/gdb/testsuite/gdb.trace/save-trace.exp	Sat Jan 21 15:28:49 2006
@@ -58,6 +58,14 @@ if { $baseline == -1 } then {
     return;
 }
 
+# We generously give ourselves one "pass" if we successfully 
+# detect that this test cannot be run on this target!
+if { ![gdb_target_supports_trace] } then {
+    pass "Current target does not supporst trace"
+    return 1;
+
+}
+
 set testline1 [expr $baseline + 4]
 set testline2 [expr $baseline + 5]
 set testline3 [expr $baseline + 6]
diff --exclude-from=exclude.lst -Nrup gdb-6.4/gdb/testsuite/lib/gdb.exp gdb-6.4-m68hc1x/gdb/testsuite/lib/gdb.exp
--- gdb-6.4/gdb/testsuite/lib/gdb.exp	Wed Sep 28 00:39:03 2005
+++ gdb-6.4-m68hc1x/gdb/testsuite/lib/gdb.exp	Sat Jan 21 15:28:49 2006
@@ -1153,6 +1153,9 @@ proc skip_cplus_tests {} {
     if { [istarget "m6812-*-*"] } {
 	return 1
     }
+    if { [istarget "m6811-*-*"] } {
+	return 1
+    }
     return 0
 }
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/include/gdb/ChangeLog.M68HC11 gdb-6.4-m68hc1x/include/gdb/ChangeLog.M68HC11
--- gdb-6.4/include/gdb/ChangeLog.M68HC11	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/include/gdb/ChangeLog.M68HC11	Sun Jan 22 22:19:11 2006
@@ -0,0 +1,4 @@
+2006-01-22  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* remote-sim.h (SIGTRAP): Define for mingw32
+
diff --exclude-from=exclude.lst -Nrup gdb-6.4/include/gdb/remote-sim.h gdb-6.4-m68hc1x/include/gdb/remote-sim.h
--- gdb-6.4/include/gdb/remote-sim.h	Fri Feb 28 00:13:32 2003
+++ gdb-6.4-m68hc1x/include/gdb/remote-sim.h	Sat Jan 21 17:57:30 2006
@@ -22,6 +22,10 @@ Foundation, Inc., 59 Temple Place - Suit
 #if !defined (REMOTE_SIM_H)
 #define REMOTE_SIM_H 1
 
+#ifndef SIGTRAP
+#define SIGTRAP 5
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/ChangeLog.M68HC11 gdb-6.4-m68hc1x/sim/common/ChangeLog.M68HC11
--- gdb-6.4/sim/common/ChangeLog.M68HC11	Thu Jan  1 01:00:00 1970
+++ gdb-6.4-m68hc1x/sim/common/ChangeLog.M68HC11	Sat Jan 21 15:28:49 2006
@@ -0,0 +1,44 @@
+2004-08-03  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* callback.c (os_ftruncate): Don't compile on Mingw32.
+	(os_truncate): Likewise.
+	(default_callback): Use null for the above
+
+2004-02-01  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* aclocal.m4 (SIM_AC_COMMON): Check for winsock.h and bind().
+
+2003-10-05  Stephane Carrez  <stcarrez@nerim.fr>
+
+	From 2003-05-10 <fernando@seventh.com.br>
+	* sim-io.c (sim_io_poll_read): Fix reading of input keyboard on
+	Windows.
+
+2002-08-11  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* sim-core.h: Use address_word to specify the base and size
+	of the memory mapping (necessary when sizeof(address_word) >
+	sizeof(unsigned_word)).
+	* sim-memopt.h: Likewise.
+	* hw-base.c (panic_hw_io_read_buffer): Likewise.
+	(panic_hw_io_write_buffer): Likewise.
+	* sim-core.c (sim_core_write_buffer): Likewise for raddr.
+	(sim_core_read_buffer): Likewise.
+	* dv-glue.c (hw_glue_io_read_buffer): Likewise.
+	(hw_glue_io_write_buffer): Likewise.
+	* dv-pal.c (hw_pal_io_write_buffer): Likewise.
+	(hw_pal_io_read_buffer): Likewise.
+	* sim-hw.c (sim_hw_io_read_buffer): Likewise.
+	(sim_hw_io_write_buffer): Likewise.
+	(sim_cpu_hw_io_read_buffer): Likewise.
+	(sim_cpu_hw_io_write_buffer): Likewise.
+
+2002-08-11  Stephane Carrez  <stcarrez@nerim.fr>
+
+	* hw-instances.c (panic_hw_instance_read): Use unsigned_cell for
+	the length to conform to hw_instance_read_method type.
+	* sim-profile.c (profile_print_addr_ranges): Compile only when
+	SIM_HAVE_ADDR_RANGE.
+	* sim-memopt.c: Include <unistd.h> for close prototype.
+	(do_memopt_add): Use %ld since bytes is a unsigned long.
+
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/aclocal.m4 gdb-6.4-m68hc1x/sim/common/aclocal.m4
--- gdb-6.4/sim/common/aclocal.m4	Wed Mar 23 19:55:14 2005
+++ gdb-6.4-m68hc1x/sim/common/aclocal.m4	Sat Jan 21 15:28:49 2006
@@ -53,11 +53,37 @@ AC_CHECK_HEADERS(stdlib.h string.h strin
 AC_CHECK_HEADERS(sys/time.h sys/resource.h)
 AC_CHECK_HEADERS(fcntl.h fpu_control.h)
 AC_CHECK_HEADERS(dlfcn.h errno.h sys/stat.h)
+AC_CHECK_HEADERS(winsock.h)
 AC_CHECK_FUNCS(getrusage time sigaction __setfpucw)
 
 # Check for socket libraries
 AC_CHECK_LIB(socket, bind)
 AC_CHECK_LIB(nsl, gethostbyname)
+
+dnl Check for Windows socket library.
+dnl We need a special program that include <winsock.h> and we must not
+dnl define bind() because the winsock definition can be special
+dnl (The real symbol for bind() seems to be bind@12)
+ac_save_libs="$LIBS"
+LIBS="-lwsock32 ${LIBS}"
+
+AC_MSG_CHECKING([for bind in -lwsock32])
+AC_TRY_LINK([#include <winsock.h>
+],[
+ bind(0, 0, 0);
+],found=yes, found=no)
+AC_MSG_RESULT($found)
+if test $found = yes; then
+  ac_tr_lib=HAVE_LIB`echo nsl | sed -e 's/[^a-zA-Z0-9_]/_/g' \
+    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_lib 1
+EOF
+  LIBS="-lwsock32 ${LIBS}"
+
+else
+  LIBS="$ac_save_libs"
+fi
 
 . ${srcdir}/../../bfd/configure.host
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/callback.c gdb-6.4-m68hc1x/sim/common/callback.c
--- gdb-6.4/sim/common/callback.c	Fri Jul  8 10:05:35 2005
+++ gdb-6.4-m68hc1x/sim/common/callback.c	Sat Jan 21 15:28:49 2006
@@ -584,6 +584,7 @@ os_lstat (p, file, buf)
 #endif
 }
 
+#if !defined(__MINGW32__)
 static int 
 os_ftruncate (p, fd, len)
      host_callback *p;
@@ -608,6 +609,7 @@ os_ftruncate (p, fd, len)
 #endif
   return result;
 }
+#endif
 
 static int
 os_truncate (p, file, len)
@@ -811,8 +813,12 @@ host_callback default_callback =
   os_fstat,
   os_lstat,
 
+#if defined(__MINGW32__)
+  0, 0,
+#else
   os_ftruncate,
   os_truncate,
+#endif
 
   os_pipe,
   os_pipe_empty,
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/dv-glue.c gdb-6.4-m68hc1x/sim/common/dv-glue.c
--- gdb-6.4/sim/common/dv-glue.c	Tue May 18 23:20:07 2004
+++ gdb-6.4-m68hc1x/sim/common/dv-glue.c	Sat Jan 21 15:28:49 2006
@@ -278,7 +278,7 @@ static unsigned
 hw_glue_io_read_buffer (struct hw *me,
 			void *dest,
 			int space,
-			unsigned_word addr,
+			address_word addr,
 			unsigned nr_bytes)
 {
   struct hw_glue *glue = (struct hw_glue *) hw_data (me);
@@ -298,7 +298,7 @@ static unsigned
 hw_glue_io_write_buffer (struct hw *me,
 			 const void *source,
 			 int space,
-			 unsigned_word addr,
+			 address_word addr,
 			 unsigned nr_bytes)
 {
   struct hw_glue *glue = (struct hw_glue *) hw_data (me);
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/dv-pal.c gdb-6.4-m68hc1x/sim/common/dv-pal.c
--- gdb-6.4/sim/common/dv-pal.c	Sat Nov 23 02:12:05 2002
+++ gdb-6.4-m68hc1x/sim/common/dv-pal.c	Sat Jan 21 15:28:49 2006
@@ -341,7 +341,7 @@ static unsigned
 hw_pal_io_read_buffer (struct hw *me,
 		       void *dest,
 		       int space,
-		       unsigned_word addr,
+		       address_word addr,
 		       unsigned nr_bytes)
 {
   hw_pal_device *hw_pal = (hw_pal_device *) hw_data (me);
@@ -426,7 +426,7 @@ static unsigned
 hw_pal_io_write_buffer (struct hw *me,
 			const void *source,
 			int space,
-			unsigned_word addr,
+			address_word addr,
 			unsigned nr_bytes)
 {
   hw_pal_device *hw_pal = (hw_pal_device*) hw_data (me);
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/dv-sockser.c gdb-6.4-m68hc1x/sim/common/dv-sockser.c
--- gdb-6.4/sim/common/dv-sockser.c	Fri Aug 11 02:48:51 2000
+++ gdb-6.4-m68hc1x/sim/common/dv-sockser.c	Sat Jan 21 15:28:49 2006
@@ -42,6 +42,9 @@ with this program; if not, write to the 
 #include <errno.h>
 #include <sys/types.h>
 #include <sys/time.h>
+#ifdef _WIN32
+#include <winsock.h>
+#else
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <netdb.h>
@@ -50,6 +53,7 @@ with this program; if not, write to the 
 #ifndef __CYGWIN32__
 #include <netinet/tcp.h>
 #endif
+#endif
 
 #include "sim-assert.h"
 #include "sim-options.h"
@@ -198,6 +202,7 @@ dv_sockser_init (SIM_DESC sd)
       return SIM_RC_OK;
     }
 
+#ifdef SIGPIPE
   /* Handle writes to missing client -> SIGPIPE.
      ??? Need a central signal management module.  */
   {
@@ -207,7 +212,7 @@ dv_sockser_init (SIM_DESC sd)
     if (orig != SIG_DFL && orig != SIG_IGN)
       signal (SIGPIPE, orig);
   }
-
+#endif
   return SIM_RC_OK;
 }
 
@@ -274,6 +279,7 @@ connected_p (SIM_DESC sd)
   if (sockser_fd < 0)
     return 0;
 
+#ifdef F_GETFL
   /* Set non-blocking i/o.  */
   flags = fcntl (sockser_fd, F_GETFL);
   flags |= O_NONBLOCK | O_NDELAY;
@@ -284,6 +290,7 @@ connected_p (SIM_DESC sd)
       sockser_fd = -1;
       return 0;
     }
+#endif
   return 1;
 }
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/hw-base.c gdb-6.4-m68hc1x/sim/common/hw-base.c
--- gdb-6.4/sim/common/hw-base.c	Sat Nov 23 02:12:05 2002
+++ gdb-6.4-m68hc1x/sim/common/hw-base.c	Sat Jan 21 15:28:49 2006
@@ -217,7 +217,7 @@ static unsigned
 panic_hw_io_read_buffer (struct hw *me,
 			 void *dest,
 			 int space,
-			 unsigned_word addr,
+			 address_word addr,
 			 unsigned nr_bytes)
 {
   hw_abort (me, "no io-read method");
@@ -228,7 +228,7 @@ static unsigned
 panic_hw_io_write_buffer (struct hw *me,
 			  const void *source,
 			  int space,
-			  unsigned_word addr,
+			  address_word addr,
 			  unsigned nr_bytes)
 {
   hw_abort (me, "no io-write method");
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/hw-device.h gdb-6.4-m68hc1x/sim/common/hw-device.h
--- gdb-6.4/sim/common/hw-device.h	Sat Nov 23 02:12:05 2002
+++ gdb-6.4-m68hc1x/sim/common/hw-device.h	Sat Jan 21 15:28:49 2006
@@ -231,7 +231,7 @@ typedef unsigned (hw_io_read_buffer_meth
      (struct hw *me,
       void *dest,
       int space,
-      unsigned_word addr,
+      address_word addr,
       unsigned nr_bytes);
 
 #define hw_io_read_buffer(hw, dest, space, addr, nr_bytes) \
@@ -244,7 +244,7 @@ typedef unsigned (hw_io_write_buffer_met
      (struct hw *me,
       const void *source,
       int space,
-      unsigned_word addr,
+      address_word addr,
       unsigned nr_bytes);
 
 #define hw_io_write_buffer(hw, src, space, addr, nr_bytes) \
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/hw-instances.c gdb-6.4-m68hc1x/sim/common/hw-instances.c
--- gdb-6.4/sim/common/hw-instances.c	Sat Nov 23 02:12:05 2002
+++ gdb-6.4-m68hc1x/sim/common/hw-instances.c	Sat Jan 21 15:28:49 2006
@@ -126,7 +126,7 @@ hw_instance_delete (struct hw_instance *
 static int
 panic_hw_instance_read (struct hw_instance *instance,
 			void *addr,
-			unsigned_word len)
+			unsigned_cell len)
 {
   hw_abort (hw_instance_hw (instance), "no read method");
   return -1;
@@ -137,7 +137,7 @@ panic_hw_instance_read (struct hw_instan
 static int
 panic_hw_instance_write (struct hw_instance *instance,
 			 const void *addr,
-			 unsigned_word len)
+			 unsigned_cell len)
 {
   hw_abort (hw_instance_hw (instance), "no write method");
   return -1;
@@ -146,8 +146,8 @@ panic_hw_instance_write (struct hw_insta
 
 static int
 panic_hw_instance_seek (struct hw_instance *instance,
-			unsigned_word pos_hi,
-			unsigned_word pos_lo)
+			unsigned_cell pos_hi,
+			unsigned_cell pos_lo)
 {
   hw_abort (hw_instance_hw (instance), "no seek method");
   return -1;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-core.c gdb-6.4-m68hc1x/sim/common/sim-core.c
--- gdb-6.4/sim/common/sim-core.c	Fri Dec 19 12:43:56 2003
+++ gdb-6.4-m68hc1x/sim/common/sim-core.c	Sat Jan 21 15:28:49 2006
@@ -518,7 +518,7 @@ sim_core_read_buffer (SIM_DESC sd,
   unsigned count = 0;
   while (count < len)
  {
-    unsigned_word raddr = addr + count;
+    address_word raddr = addr + count;
     sim_core_mapping *mapping =
       sim_core_find_mapping (core, map,
 			    raddr, /*nr-bytes*/1,
@@ -584,7 +584,7 @@ sim_core_write_buffer (SIM_DESC sd,
   unsigned count = 0;
   while (count < len)
     {
-      unsigned_word raddr = addr + count;
+      address_word raddr = addr + count;
       sim_core_mapping *mapping =
 	sim_core_find_mapping (core, map,
 			       raddr, /*nr-bytes*/1,
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-core.h gdb-6.4-m68hc1x/sim/common/sim-core.h
--- gdb-6.4/sim/common/sim-core.h	Sat Nov 23 02:12:05 2002
+++ gdb-6.4-m68hc1x/sim/common/sim-core.h	Sat Jan 21 15:28:49 2006
@@ -51,9 +51,9 @@ struct _sim_core_mapping {
   /* common */
   int level;
   int space;
-  unsigned_word base;
-  unsigned_word bound;
-  unsigned_word nr_bytes;
+  address_word base;
+  address_word bound;
+  address_word nr_bytes;
   unsigned mask;
   /* memory map */
   void *free_buffer;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-hw.c gdb-6.4-m68hc1x/sim/common/sim-hw.c
--- gdb-6.4/sim/common/sim-hw.c	Thu Jul 27 13:34:30 2000
+++ gdb-6.4-m68hc1x/sim/common/sim-hw.c	Sat Jan 21 15:28:49 2006
@@ -1,5 +1,5 @@
 /* Simulator hardware option handling.
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 2002 Free Software Foundation, Inc.
    Contributed by Cygnus Support and Andrew Cagney.
 
 This file is part of GDB, the GNU debugger.
@@ -339,7 +339,7 @@ sim_cpu_hw_io_read_buffer (sim_cpu *cpu,
 			   struct hw *hw,
 			   void *dest,
 			   int space,
-			   unsigned_word addr,
+			   address_word addr,
 			   unsigned nr_bytes)
 {
   SIM_DESC sd = CPU_STATE (cpu);
@@ -355,7 +355,7 @@ sim_cpu_hw_io_write_buffer (sim_cpu *cpu
 			    struct hw *hw,
 			    const void *source,
 			    int space,
-			    unsigned_word addr,
+			    address_word addr,
 			    unsigned nr_bytes)
 {
   SIM_DESC sd = CPU_STATE (cpu);
@@ -375,7 +375,7 @@ sim_hw_io_read_buffer (struct sim_state 
 		       struct hw *hw,
 		       void *dest,
 		       int space,
-		       unsigned_word addr,
+		       address_word addr,
 		       unsigned nr_bytes)
 {
   STATE_HW (sd)->cpu = NULL;
@@ -387,7 +387,7 @@ sim_hw_io_write_buffer (struct sim_state
 			struct hw *hw,
 			const void *source,
 			int space,
-			unsigned_word addr,
+			address_word addr,
 			unsigned nr_bytes)
 {
   STATE_HW (sd)->cpu = NULL;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-hw.h gdb-6.4-m68hc1x/sim/common/sim-hw.h
--- gdb-6.4/sim/common/sim-hw.h	Fri Apr 16 03:34:57 1999
+++ gdb-6.4-m68hc1x/sim/common/sim-hw.h	Sat Jan 21 15:28:49 2006
@@ -1,5 +1,5 @@
 /* Device definitions.
-   Copyright (C) 1998 Free Software Foundation, Inc.
+   Copyright (C) 1998, 2002 Free Software Foundation, Inc.
    Contributed by Cygnus Support.
 
 This file is part of GDB, the GNU debugger.
@@ -62,7 +62,7 @@ void sim_cpu_hw_io_read_buffer
  struct hw *hw,
  void *dest,
  int space,
- unsigned_word addr,
+ address_word addr,
  unsigned nr_bytes);
 
 void sim_cpu_hw_io_write_buffer
@@ -71,7 +71,7 @@ void sim_cpu_hw_io_write_buffer
  struct hw *hw,
  const void *source,
  int space,
- unsigned_word addr,
+ address_word addr,
  unsigned nr_bytes);
 
 
@@ -83,7 +83,7 @@ unsigned sim_hw_io_read_buffer
  struct hw *hw,
  void *dest,
  int space,
- unsigned_word addr,
+ address_word addr,
  unsigned nr_bytes);
 
 unsigned sim_hw_io_write_buffer
@@ -91,7 +91,7 @@ unsigned sim_hw_io_write_buffer
  struct hw *hw,
  const void *source,
  int space,
- unsigned_word addr,
+ address_word addr,
  unsigned nr_bytes);
 
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-io.c gdb-6.4-m68hc1x/sim/common/sim-io.c
--- gdb-6.4/sim/common/sim-io.c	Sat Nov 23 02:12:05 2002
+++ gdb-6.4-m68hc1x/sim/common/sim-io.c	Sat Jan 21 15:28:49 2006
@@ -386,6 +386,15 @@ sim_io_poll_read (SIM_DESC sd,
     }
   return result;
 #else
+#ifdef _WIN32
+  /* For Windows, use _kbhit() to see whether some input is available.  */
+  if (sim_io_fd == STDIN_FILENO) {
+    int result = 0;
+    while (_kbhit() && result < sizeof_buf)
+      buf[result++] = _getch();
+    return result;
+  } else
+#endif
   return sim_io_read (sd, sim_io_fd, buf, sizeof_buf);
 #endif
 }
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-memopt.h gdb-6.4-m68hc1x/sim/common/sim-memopt.h
--- gdb-6.4/sim/common/sim-memopt.h	Tue Mar 20 18:13:39 2001
+++ gdb-6.4-m68hc1x/sim/common/sim-memopt.h	Sat Jan 21 15:28:49 2006
@@ -27,8 +27,8 @@ typedef struct _sim_memopt sim_memopt;
 struct _sim_memopt {
   int level;
   int space;
-  unsigned_word addr;
-  unsigned_word nr_bytes;
+  address_word addr;
+  address_word nr_bytes;
   unsigned modulo;
   void *buffer;
   unsigned long munmap_length;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-profile.c gdb-6.4-m68hc1x/sim/common/sim-profile.c
--- gdb-6.4/sim/common/sim-profile.c	Thu Feb 15 22:14:40 2001
+++ gdb-6.4-m68hc1x/sim/common/sim-profile.c	Sat Jan 21 15:28:49 2006
@@ -1050,6 +1050,7 @@ profile_print_speed (sim_cpu *cpu)
     }
 }
 
+#ifdef SIM_HAVE_ADDR_RANGE
 /* Print selected address ranges.  */
 
 static void
@@ -1070,6 +1071,7 @@ profile_print_addr_ranges (sim_cpu *cpu)
       sim_io_printf (sd, "\n");
     }
 }
+#endif
 
 /* Top level function to print all summary profile information.
    It is [currently] intended that all such data is printed by this function.
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-signal.c gdb-6.4-m68hc1x/sim/common/sim-signal.c
--- gdb-6.4/sim/common/sim-signal.c	Fri Apr 16 03:34:59 1999
+++ gdb-6.4-m68hc1x/sim/common/sim-signal.c	Sat Jan 21 15:28:49 2006
@@ -27,7 +27,7 @@ with this program; if not, write to the 
    to not think the process has died (so it can be debugged at the point of
    failure).  */
 
-#ifdef _MSC_VER
+#if defined(_MSC_VER) || defined(__MINGW32__)
 #ifndef SIGTRAP
 #define SIGTRAP 5
 #endif
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/common/sim-trace.c gdb-6.4-m68hc1x/sim/common/sim-trace.c
--- gdb-6.4/sim/common/sim-trace.c	Fri Oct 31 06:32:46 2003
+++ gdb-6.4-m68hc1x/sim/common/sim-trace.c	Sat Jan 21 15:28:49 2006
@@ -241,7 +241,9 @@ trace_option_handler (SIM_DESC sd, sim_c
 		      char *arg, int is_command)
 {
   int n;
+#ifdef SIM_HAVE_ADDR_RANGE
   int cpu_nr;
+#endif
 
   switch (opt)
     {
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/configure gdb-6.4-m68hc1x/sim/m68hc11/configure
--- gdb-6.4/sim/m68hc11/configure	Wed Mar 23 19:55:17 2005
+++ gdb-6.4-m68hc1x/sim/m68hc11/configure	Sat Jan 21 15:28:49 2006
@@ -6800,6 +6800,45 @@ _ACEOF
 fi
 
 
+ac_save_libs="$LIBS"
+LIBS="-lwsock32 ${LIBS}"
+
+echo $ac_n "checking for bind in -lwsock32""... $ac_c" 1>&6
+echo "configure:3297: checking for bind in -lwsock32" >&5
+cat > conftest.$ac_ext <<EOF
+#line 3299 "configure"
+#include "confdefs.h"
+#include <winsock.h>
+
+int main() {
+
+ bind(0, 0, 0);
+
+; return 0; }
+EOF
+if { (eval echo configure:3309: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+  rm -rf conftest*
+  found=yes
+else
+  echo "configure: failed program was:" >&5
+  cat conftest.$ac_ext >&5
+  rm -rf conftest*
+  found=no
+fi
+rm -f conftest*
+echo "$ac_t""$found" 1>&6
+if test $found = yes; then
+  ac_tr_lib=HAVE_LIB`echo nsl | sed -e 's/^a-zA-Z0-9_/_/g' \
+    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
+  cat >> confdefs.h <<EOF
+#define $ac_tr_lib 1
+EOF
+  LIBS="-lwsock32 ${LIBS}"
+
+else
+  LIBS="$ac_save_libs"
+fi
+
 . ${srcdir}/../../bfd/configure.host
 
 
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/dv-m68hc11.c gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11.c
--- gdb-6.4/sim/m68hc11/dv-m68hc11.c	Fri Aug  8 23:00:55 2003
+++ gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11.c	Sat Jan 21 15:28:50 2006
@@ -831,7 +831,7 @@ static unsigned
 m68hc11cpu_io_read_buffer (struct hw *me,
 			   void *dest,
 			   int space,
-			   unsigned_word base,
+			   address_word base,
 			   unsigned nr_bytes)
 {
   SIM_DESC sd;
@@ -981,7 +981,7 @@ m68hc11cpu_set_port (struct hw *me, sim_
 
 static void
 m68hc11cpu_io_write (struct hw *me, sim_cpu *cpu,
-                     unsigned_word addr, uint8 val)
+                     address_word addr, uint8 val)
 {
   switch (addr)
     {
@@ -1079,7 +1079,7 @@ static unsigned
 m68hc11cpu_io_write_buffer (struct hw *me,
 			    const void *source,
 			    int space,
-			    unsigned_word base,
+			    address_word base,
 			    unsigned nr_bytes)
 {
   SIM_DESC sd;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/dv-m68hc11eepr.c gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11eepr.c
--- gdb-6.4/sim/m68hc11/dv-m68hc11eepr.c	Tue Aug 13 11:01:16 2002
+++ gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11eepr.c	Sat Jan 21 15:28:50 2006
@@ -393,7 +393,7 @@ static unsigned
 m68hc11eepr_io_read_buffer (struct hw *me,
 			    void *dest,
 			    int space,
-			    unsigned_word base,
+			    address_word base,
 			    unsigned nr_bytes)
 {
   SIM_DESC sd;
@@ -448,7 +448,7 @@ static unsigned
 m68hc11eepr_io_write_buffer (struct hw *me,
 			     const void *source,
 			     int space,
-			     unsigned_word base,
+			     address_word base,
 			     unsigned nr_bytes)
 {
   SIM_DESC sd;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/dv-m68hc11sio.c gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11sio.c
--- gdb-6.4/sim/m68hc11/dv-m68hc11sio.c	Fri Aug  8 23:02:24 2003
+++ gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11sio.c	Sat Jan 21 15:28:50 2006
@@ -492,7 +492,7 @@ static unsigned
 m68hc11sio_io_read_buffer (struct hw *me,
                            void *dest,
                            int space,
-                           unsigned_word base,
+                           address_word base,
                            unsigned nr_bytes)
 {
   SIM_DESC sd;
@@ -537,7 +537,7 @@ static unsigned
 m68hc11sio_io_write_buffer (struct hw *me,
                             const void *source,
                             int space,
-                            unsigned_word base,
+                            address_word base,
                             unsigned nr_bytes)
 {
   SIM_DESC sd;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/dv-m68hc11spi.c gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11spi.c
--- gdb-6.4/sim/m68hc11/dv-m68hc11spi.c	Fri Aug  8 23:02:24 2003
+++ gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11spi.c	Sat Jan 21 15:28:50 2006
@@ -381,7 +381,7 @@ static unsigned
 m68hc11spi_io_read_buffer (struct hw *me,
                            void *dest,
                            int space,
-                           unsigned_word base,
+                           address_word base,
                            unsigned nr_bytes)
 {
   SIM_DESC sd;
@@ -426,7 +426,7 @@ static unsigned
 m68hc11spi_io_write_buffer (struct hw *me,
                             const void *source,
                             int space,
-                            unsigned_word base,
+                            address_word base,
                             unsigned nr_bytes)
 {
   SIM_DESC sd;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/dv-m68hc11tim.c gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11tim.c
--- gdb-6.4/sim/m68hc11/dv-m68hc11tim.c	Fri Aug  8 23:02:24 2003
+++ gdb-6.4-m68hc1x/sim/m68hc11/dv-m68hc11tim.c	Sat Jan 21 15:28:50 2006
@@ -638,7 +638,7 @@ static unsigned
 m68hc11tim_io_read_buffer (struct hw *me,
                            void *dest,
                            int space,
-                           unsigned_word base,
+                           address_word base,
                            unsigned nr_bytes)
 {
   SIM_DESC sd;
@@ -687,7 +687,7 @@ static unsigned
 m68hc11tim_io_write_buffer (struct hw *me,
                             const void *source,
                             int space,
-                            unsigned_word base,
+                            address_word base,
                             unsigned nr_bytes)
 {
   SIM_DESC sd;
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/dv-nvram.c gdb-6.4-m68hc1x/sim/m68hc11/dv-nvram.c
--- gdb-6.4/sim/m68hc11/dv-nvram.c	Fri Nov 24 21:53:35 2000
+++ gdb-6.4-m68hc1x/sim/m68hc11/dv-nvram.c	Sat Jan 21 15:28:50 2006
@@ -258,7 +258,7 @@ static unsigned
 nvram_io_read_buffer (struct hw *me,
                       void *dest,
                       int space,
-                      unsigned_word base,
+                      address_word base,
                       unsigned nr_bytes)
 {
   struct nvram *controller = hw_data (me);
@@ -281,7 +281,7 @@ static unsigned
 nvram_io_write_buffer (struct hw *me,
                        const void *source,
                        int space,
-                       unsigned_word base,
+                       address_word base,
                        unsigned nr_bytes)
 {
   struct nvram *controller = hw_data (me);
diff --exclude-from=exclude.lst -Nrup gdb-6.4/sim/m68hc11/m68hc11_sim.c gdb-6.4-m68hc1x/sim/m68hc11/m68hc11_sim.c
--- gdb-6.4/sim/m68hc11/m68hc11_sim.c	Fri Aug  8 23:00:55 2003
+++ gdb-6.4-m68hc1x/sim/m68hc11/m68hc11_sim.c	Sat Jan 21 15:28:50 2006
@@ -291,8 +291,8 @@ cpu_get_indexed_operand_addr (sim_cpu* c
 	  return 0;
 	}
       reg = (code >> 3) & 0x03;
-      addr = cpu_get_reg (cpu, reg);
-      addr += cpu_fetch16 (cpu);
+      addr = cpu_fetch16 (cpu);
+      addr += cpu_get_reg (cpu, reg);
       addr = memory_read16 (cpu, addr);
       cpu_add_cycles (cpu, 1);
     }
@@ -765,7 +765,7 @@ cpu_special (sim_cpu *cpu, enum M6811_Sp
     case M6811_WAI:
       /* In the ELF-start mode, we are in a special mode where
 	 the WAI corresponds to an exit.  */
-      if (cpu->cpu_use_elf_start)
+      if (cpu->cpu_use_elf_start || 1)
         {
           cpu_set_pc (cpu, cpu->cpu_insn_pc);
           sim_engine_halt (CPU_STATE (cpu), cpu,