dark0707
/
px4-firmware
forked from Archive/PX4-Autopilot
1
0
Fork 0
Code Pull Requests Activity
px4-firmware/misc/buildroot/toolchain/gdb/6.4/700-m68hc1x-20060122.patch

5683 lines
168 KiB
Diff
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

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,
View Git Blame Copy Permalink