diff options
Diffstat (limited to 'gdb')
| -rw-r--r-- | gdb/.Sanitize | 1 | ||||
| -rw-r--r-- | gdb/ChangeLog | 8 | ||||
| -rw-r--r-- | gdb/configure.in | 1 | ||||
| -rw-r--r-- | gdb/remote-est.c | 589 | ||||
| -rw-r--r-- | gdb/remote-utils.c | 1 |
5 files changed, 600 insertions, 0 deletions
diff --git a/gdb/.Sanitize b/gdb/.Sanitize index 7cd9a14..d707964 100644 --- a/gdb/.Sanitize +++ b/gdb/.Sanitize @@ -228,6 +228,7 @@ remote-bug.c remote-e7000.c remote-eb.c remote-es.c +remote-est.c remote-hms.c remote-mips.c remote-mm.c diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 36b3318..d8b0969 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,11 @@ +Fri Dec 23 17:03:13 1994 Steve Chamberlain (sac@jonny.cygnus.com) + + * remote-est.c: New file supports EST-300 CPU32 background + mode ICE. + * remote-utils.c (sr_com): Call registers_changed. + * configure.in (m68*-*-est*): New configuration. + * config/m68k/tm-est.h: New file. + Fri Dec 23 16:18:50 1994 Stu Grossman (grossman@cygnus.com) * Makefile.in (CLIBS): Put LIBIBERTY last. diff --git a/gdb/configure.in b/gdb/configure.in index e89f27f..7f14b2f 100644 --- a/gdb/configure.in +++ b/gdb/configure.in @@ -273,6 +273,7 @@ m68*-*-sunos3*) gdb_target=sun3os3 ;; m68*-*-sunos4*) gdb_target=sun3os4 ;; m68*-*-sysv4*) gdb_target=m68kv4 ;; m68*-*-vxworks*) gdb_target=vxworks68 ;; +m68*-*-est*) gdb_target=est ;; m88*-harris-cxux*) gdb_target=cxux ;; m88*-motorola-sysv4*) gdb_target=delta88v4 ;; diff --git a/gdb/remote-est.c b/gdb/remote-est.c new file mode 100644 index 0000000..1fbdfac --- /dev/null +++ b/gdb/remote-est.c @@ -0,0 +1,589 @@ +/* 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); +} diff --git a/gdb/remote-utils.c b/gdb/remote-utils.c index f1e949a..b23aa70 100644 --- a/gdb/remote-utils.c +++ b/gdb/remote-utils.c @@ -396,6 +396,7 @@ sr_com (args, fromtty) sr_write_cr (args); sr_write ("\030", 1); + registers_changed (); gr_expect_prompt (); } |