zrzk
/
px4_autopilot
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
201 Commits
14 Branches
0 Tags
306 MiB
 
 
 
 
 
 
Tree: a02dc4c1dc
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'a02dc4c1dc'
${ noResults }
px4_autopilot/misc/buildroot/toolchain/gdb/6.4/700-m68hc1x-20060122.patch

5682 lines
168 KiB
Raw Blame History Escape

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,