--- /dev/null
+/* Remote debugging interface for EST-300 ICE, for GDB
+ Copyright 1994 Free Software Foundation, Inc.
+ Contributed by Cygnus Support.
+
+ Written by Steve Chamberlain for Cygnus Support.
+
+ 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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+#include "defs.h"
+#include "command.h"
+#include "gdbcore.h"
+#include "target.h"
+#include "wait.h"
+#include <varargs.h>
+#include <signal.h>
+#include <string.h>
+#include <sys/types.h>
+#include "serial.h"
+#include "remote-utils.h"
+
+
+static void expect_char PARAMS ((int));
+
+
+static void
+write_and_expect (x)
+char *x;
+{
+ sr_write_cr (x);
+ sr_expect (x);
+}
+
+static void
+expect_char (want)
+ int want;
+{
+ int c = sr_readchar ();
+ while (c != want)
+ c = sr_readchar ();
+}
+
+
+static void
+expect_prompt ()
+{
+ expect_char ('>');
+}
+
+static int
+get_hex_digit (ch)
+ int ch;
+{
+ if (ch >= '0' && ch <= '9')
+ return ch - '0';
+ else if (ch >= 'A' && ch <= 'F')
+ return ch - 'A' + 10;
+ else if (ch >= 'a' && ch <= 'f')
+ return ch - 'a' + 10;
+ return -1;
+}
+
+static int
+get_hex (start)
+ int *start;
+{
+ int value = get_hex_digit (*start);
+ int try;
+
+ *start = sr_readchar ();
+ while ((try = get_hex_digit (*start)) >= 0)
+ {
+ value <<= 4;
+ value += try;
+ *start = sr_readchar ();
+ }
+ return value;
+}
+
+/* Tell the remote machine to resume. */
+
+static void
+est_resume (pid, step, sig)
+ int pid, step, sig;
+{
+ write_and_expect (step ? ".SI" : ".GO");
+}
+
+/* A reg dump looks like
+ D0 = 00000000 D1 = 00000000 D2 = 00000000 D3 = 00000000
+ D4 = 00000000 D5 = 00000000 D6 = 00000000 D7 = 00000000
+ A0 = 00000000 A1 = 00000000 A2 = 00000000 A3 = 00000000
+ A4 = 00000000 A5 = 00000000 A6 = 00000000 A7 = 001104FE
+ USP = 00110400 SSP*= 001104FE PC = 00229BBC SR = 2000
+ VBR = 00110000 SFC = 0005 DFC = 0005
+
+or
+
+00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00000000 00001234 00000000 001104FE 00110400 001104FE 00229BBC 2000 00110000 0005 0005
+*/
+
+static int
+target_to_gdb_rn (rn)
+ int rn;
+{
+ if (rn < 16)
+ return rn;
+ if (rn == 18)
+ return PC_REGNUM;
+ if (rn == 19)
+ return PS_REGNUM;
+ return -1;
+}
+
+
+static void est_fetch_register ();
+static void
+est_fetch_registers ()
+{
+ int regno;
+ unsigned long val;
+ int c;
+ int target_rn;
+ char buf[4];
+ write_and_expect (".DR");
+ buf[0] = 0;
+ buf[1] = 0;
+ buf[2] = 0;
+ buf[3] = 0;
+ for (regno = 0; regno < NUM_REGS; regno++)
+ supply_register (regno, buf);
+
+ c = sr_readchar ();
+ for (target_rn = 0; target_rn < 23; target_rn++)
+ {
+ unsigned long val;
+ while (!isdigit (c) && !isalpha (c))
+ c = sr_readchar ();
+
+ while (isdigit (c) || (c >= 'A' && c <= 'F'))
+ {
+ val <<= 4;
+ if (isdigit (c))
+ val = val + c - '0';
+ else
+ val = val + c - 'A' + 10;
+ c = sr_readchar ();
+ }
+
+ regno = target_to_gdb_rn (target_rn);
+ if (regno >= 0)
+ {
+ buf[0] = val >> 24;
+ buf[1] = val >> 16;
+ buf[2] = val >> 8;
+ buf[3] = val >> 0;
+ supply_register (regno, buf);
+ }
+ }
+ expect_prompt();
+}
+
+/* Fetch register REGNO, or all registers if REGNO is -1.
+ Returns errno value. */
+
+static
+void
+est_fetch_register (regno)
+ int regno;
+{
+ est_fetch_registers ();
+}
+
+/* Store the remote registers from the contents of the block REGS. */
+
+static void est_store_register ();
+static void
+est_store_registers ()
+{
+ int regno;
+
+ for (regno = 0; regno < 18; regno++)
+ est_store_register (regno);
+ registers_changed ();
+}
+
+/* Store register REGNO, or all if REGNO == 0.
+ Return errno value. */
+static void
+est_store_register (regno)
+ int regno;
+{
+ char buf[20];
+ if (regno == -1)
+ {
+ est_store_registers ();
+ return;
+ }
+
+ if (regno < 8)
+ sprintf (buf, ".SR D%d %x", regno, read_register (regno));
+ else if (regno < 16)
+ sprintf (buf, ".SR A%d %x", regno - 8, read_register (regno));
+ else if (regno == PC_REGNUM)
+ sprintf (buf, ".SR PC %x", read_register (regno));
+ else if (regno == PS_REGNUM)
+ sprintf (buf, ".SR SR %x", read_register (regno));
+ else
+ return;
+ write_and_expect (buf);
+ expect_prompt ();
+}
+
+/* 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
+int
+stickbyte (where, what)
+ char *where;
+ unsigned int what;
+{
+ static CONST char digs[] = "0123456789ABCDEF";
+ where[0] = digs[(what >> 4) & 0xf];
+ where[1] = digs[(what & 0xf) & 0xf];
+ return what;
+}
+
+/* Copy LEN bytes of data from debugger memory at MYADDR
+ to inferior's memory at MEMADDR. Returns length moved. */
+
+static int
+est_write_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ unsigned char *myaddr;
+ int len;
+{
+ int i;
+#define maxstride 128
+ int stride;
+
+ write_and_expect (".DL");
+ expect_char ('+');
+ for (i = 0; i < len; i += stride)
+ {
+ char compose[maxstride * 2 + 50];
+ int address = i + memaddr;
+ int j;
+ int check_sum;
+ int where = 0;
+ int alen;
+ stride = len - i;
+ if (stride > maxstride)
+ stride = maxstride;
+
+ compose[where++] = 'S';
+ check_sum = 0;
+ if (address >= 0xffffff)
+ {
+ alen = 4;
+ }
+ else if (address >= 0xffff)
+ {
+ alen = 3;
+ }
+ else
+ alen = 2;
+ compose[where++] = alen - 1 + '0'; /* insert type */
+ check_sum += stickbyte (compose + where, alen + stride + 1); /* Insert length */
+ where += 2;
+ while (alen > 0)
+ {
+ alen--;
+ check_sum += stickbyte (compose + where, address >> (8 * (alen)));
+ where += 2;
+ }
+
+ for (j = 0; j < stride; j++)
+ {
+ check_sum += stickbyte (compose + where, myaddr[i + j]);
+ where += 2;
+ }
+
+ stickbyte (compose + where, ~check_sum);
+
+ where += 2;
+ compose[where++] = 0;
+
+ sr_write_cr (compose);
+ while (sr_readchar () != '+')
+ sr_write_cr (compose);
+ }
+
+ /* Send the trailer record */
+ sr_write_cr ("S70500000000FA");
+ expect_prompt ();
+ return len;
+}
+
+
+
+/*
+
+ The dump memory command generates output which looks like:
+
+
+.dmb 0 100
+4E 56 FF FC 4E 71 42 AE FF FC 72 09 B2 AE FF FC NV..NqB...r.....
+6C 02 60 12 2F 2E FF FC 4E B9 00 00 00 2A 58 4F l.`./...N....*XO
+52 AE FF FC 60 E4 4E 5E 4E 75 4E 56 00 00 20 2E R...`.N^NuNV.. .
+00 08 D1 B9 00 00 00 00 4E 5E 4E 75 06 46 40 54 ........N^Nu.F@T
+04 45 44 4C 54 45 40 56 42 F4 04 64 24 45 05 05 .EDLTE@VB..d$E..
+00 6D 04 46 00 45 4C 05 04 46 04 4C 44 CD 00 65 .m.F.EL..F.LD..e
+40 45 44 55 45 45 45 46 04 44 44 40 05 4D 00 44 @EDUEEEF.DD@.M.D
+
+*/
+
+static int
+est_read_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ unsigned char *myaddr;
+ int len;
+{
+ int count;
+ int c;
+ char buf[20];
+ /* Starting address of this pass. */
+
+ if (((memaddr - 1) + len) < memaddr)
+ {
+ errno = EIO;
+ return 0;
+ }
+
+ sprintf (buf, ".dmb %x %x", memaddr, len);
+ write_and_expect (buf);
+ count = 0;
+
+ c = sr_readchar ();
+
+ while (count < len)
+ {
+ while (!isdigit (c) && !isalpha (c)) {
+ if (c == '!')
+ {
+ expect_prompt();
+ errno =EIO;
+ return 0;
+
+ }
+ c = sr_readchar ();
+ }
+ myaddr[count++] = get_hex (&c);
+ c = sr_readchar ();
+ if (c == ' ')
+ {
+ c = sr_readchar ();
+ if (c == ' ')
+ while (c != '\r')
+ c = sr_readchar ();
+ }
+ }
+
+ expect_prompt ();
+
+
+ return len;
+}
+
+static int
+est_xfer_inferior_memory (memaddr, myaddr, len, write, target)
+ CORE_ADDR memaddr;
+ unsigned char *myaddr;
+ int len;
+ int write;
+ struct target_ops *target; /* ignored */
+{
+ if (write)
+ {
+ return est_write_memory (memaddr, myaddr, len);
+ }
+ else
+ {
+ return est_read_memory (memaddr, myaddr, len);
+ }
+}
+
+
+#define MAX_DEBUG_BREAKPOINTS 100
+
+extern int memory_breakpoint_size;
+static CORE_ADDR breakaddr[MAX_DEBUG_BREAKPOINTS] =
+{0};
+
+int
+est_clear_all_breakpoints ()
+{
+ int i;
+ for (i = 0; i < MAX_DEBUG_BREAKPOINTS; i++)
+ {
+ breakaddr[i] = 0;
+ }
+
+ if (sr_is_open ())
+ {
+ write_and_expect (".RB");
+ expect_prompt ();
+ }
+ return 0;
+}
+
+static int
+est_insert_breakpoint (addr, shadow)
+ CORE_ADDR addr;
+ unsigned char *shadow;
+{
+ int i;
+
+ for (i = 0; i <= MAX_DEBUG_BREAKPOINTS; i++)
+ if (breakaddr[i] == 0)
+ {
+ char buf[20];
+ breakaddr[i] = addr;
+ sprintf (buf, ".SB %x", addr);
+ write_and_expect (buf);
+ expect_prompt ();
+ return 0;
+ }
+ error ("Too many breakpoints ( > %d) for the est\n", MAX_DEBUG_BREAKPOINTS);
+ return 1;
+}
+
+static int
+est_remove_breakpoint (addr, shadow)
+ CORE_ADDR addr;
+ unsigned char *shadow;
+{
+ int i;
+
+ for (i = 0; i < MAX_DEBUG_BREAKPOINTS; i++)
+ if (breakaddr[i] == addr)
+ {
+ char buf[20];
+ breakaddr[i] = 0;
+ sprintf (buf, ".RB %x", addr);
+ write_and_expect (buf);
+ expect_prompt ();
+ return 0;
+ }
+
+ error ("Can't find breakpoint associated with 0x%x\n", addr);
+ return 1;
+}
+
+
+/* Wait until the remote machine stops, then return,
+ storing status in STATUS just as `wait' would. */
+
+static int
+est_wait (pid, status)
+ int pid;
+ struct target_waitstatus *status;
+{
+ int c = sr_readchar ();
+ while (c != '!')
+ c = sr_readchar ();
+ /* What sort of stop */
+ c = sr_readchar ();
+ status->kind = TARGET_WAITKIND_STOPPED;
+ switch (c)
+ {
+ case 'E':
+ status->value.sig = TARGET_SIGNAL_BUS;
+ break;
+ /* Address error */
+ case 'A':
+ status->value.sig = TARGET_SIGNAL_BUS;
+ break;
+ /* Break */
+ case 'B':
+ status->value.sig = TARGET_SIGNAL_TRAP;
+ break;
+ }
+ expect_prompt ();
+ return 0;
+}
+
+void
+est_checkin ()
+{
+ write_and_expect (".in");
+ gr_expect_prompt ();
+}
+
+extern struct gr_settings est_settings;
+
+static void
+est_open (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ gr_open (args, from_tty, &est_settings);
+}
+
+/* Define the target subroutine names */
+
+struct target_ops est_ops =
+{
+ "est",
+ "Remote EST-300 target",
+ "Use a remote EST-300 ICE connected by a serial line,\n\
+or a network connection.\n\
+Arguments are the name of the device for the serial line,\n\
+the speed to connect at in bits per second.\n\
+eg\n\
+target est /dev/ttya 9600\n\
+target est foobar",
+ est_open,
+ gr_close,
+ 0,
+ gr_detach,
+ est_resume,
+ est_wait,
+ est_fetch_register,
+ est_store_register,
+ gr_prepare_to_store,
+ est_xfer_inferior_memory,
+ gr_files_info,
+ est_insert_breakpoint,
+ est_remove_breakpoint, /* Breakpoints */
+ 0,
+ 0,
+ 0,
+ 0,
+ 0, /* Terminal handling */
+ gr_kill,
+ gr_load_image, /* load */
+ 0, /* lookup_symbol */
+ gr_create_inferior,
+ gr_mourn,
+ 0, /* can_run */
+ 0, /* notice_signals */
+ 0, /* to_stop */
+ process_stratum,
+ 0, /* next */
+ 1,
+ 1,
+ 1,
+ 1,
+ 1, /* all mem, mem, stack, regs, exec */
+ 0,
+ 0, /* Section pointers */
+ OPS_MAGIC, /* Always the last thing */
+};
+
+static struct gr_settings est_settings =
+{
+ NULL, /* dcache */
+ ">", /* prompt */
+ &est_ops, /* ops */
+ est_clear_all_breakpoints,
+ est_read_memory, /* readfunc */
+ est_write_memory, /* writefunc */
+ est_checkin, /* checkin */
+};
+
+void
+_initialize_remote_est ()
+{
+ add_target (&est_ops);
+}
projects / deliverable / binutils-gdb.git / commitdiff
