--- /dev/null
+/* Remote debugging interface for Motorola's MVME187BUG monitor, an embedded
+ monitor for the m88k.
+
+ Copyright 1992, 1993 Free Software Foundation, Inc.
+ Contributed by Cygnus Support. Written by K. Richard Pixley.
+
+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 "inferior.h"
+#include "wait.h"
+#include "value.h"
+#include <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 "serial.h"
+
+/* External data declarations */
+extern int stop_soon_quietly; /* for wait_for_inferior */
+
+/* Forward data declarations */
+static struct target_ops bug_ops; /* Forward declaration */
+
+/* Forward function declarations */
+static void bug_fetch_registers ();
+static int bug_store_registers ();
+static void bug_close ();
+static int bug_clear_breakpoints ();
+
+static int quiet = 1;
+
+
+serial_t desc;
+
+/***********************************************************************/
+/* Caching stuff stolen from remote-nindy.c */
+
+/* The data cache records all the data read from the remote machine
+ since the last time it stopped.
+
+ Each cache block holds LINE_SIZE bytes of data
+ starting at a multiple-of-LINE_SIZE address. */
+
+#define LINE_SIZE_POWER 4
+#define LINE_SIZE (1<<LINE_SIZE_POWER) /* eg 1<<3 == 8 */
+#define LINE_SIZE_MASK ((LINE_SIZE-1)) /* eg 7*2+1= 111*/
+#define DCACHE_SIZE 64 /* Number of cache blocks */
+#define XFORM(x) ((x&LINE_SIZE_MASK)>>2)
+struct dcache_block
+ {
+ struct dcache_block *next, *last;
+ unsigned int addr; /* Address for which data is recorded. */
+ int data[LINE_SIZE / sizeof (int)];
+ };
+
+struct dcache_block dcache_free, dcache_valid;
+
+/* Free all the data cache blocks, thus discarding all cached data. */
+static
+void
+dcache_flush ()
+{
+ register struct dcache_block *db;
+
+ while ((db = dcache_valid.next) != &dcache_valid)
+ {
+ remque (db);
+ insque (db, &dcache_free);
+ }
+}
+
+/*
+ * If addr is present in the dcache, return the address of the block
+ * containing it.
+ */
+static
+struct dcache_block *
+dcache_hit (addr)
+ unsigned int addr;
+{
+ register struct dcache_block *db;
+
+ if (addr & 3)
+ abort ();
+
+ /* Search all cache blocks for one that is at this address. */
+ db = dcache_valid.next;
+ while (db != &dcache_valid)
+ {
+ if ((addr & ~LINE_SIZE_MASK) == db->addr)
+ return db;
+ db = db->next;
+ }
+ return NULL;
+}
+
+/* Return the int data at address ADDR in dcache block DC. */
+static
+int
+dcache_value (db, addr)
+ struct dcache_block *db;
+ unsigned int addr;
+{
+ if (addr & 3)
+ abort ();
+ return (db->data[XFORM (addr)]);
+}
+
+/* Get a free cache block, put or keep it on the valid list,
+ and return its address. The caller should store into the block
+ the address and data that it describes, then remque it from the
+ free list and insert it into the valid list. This procedure
+ prevents errors from creeping in if a ninMemGet is interrupted
+ (which used to put garbage blocks in the valid list...). */
+static
+struct dcache_block *
+dcache_alloc ()
+{
+ register struct dcache_block *db;
+
+ if ((db = dcache_free.next) == &dcache_free)
+ {
+ /* If we can't get one from the free list, take last valid and put
+ it on the free list. */
+ db = dcache_valid.last;
+ remque (db);
+ insque (db, &dcache_free);
+ }
+
+ remque (db);
+ insque (db, &dcache_valid);
+ return (db);
+}
+
+/* Return the contents of the word at address ADDR in the remote machine,
+ using the data cache. */
+static
+int
+dcache_fetch (addr)
+ CORE_ADDR addr;
+{
+ register struct dcache_block *db;
+
+ db = dcache_hit (addr);
+ if (db == 0)
+ {
+ db = dcache_alloc ();
+ immediate_quit++;
+ bug_read_inferior_memory (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
+ immediate_quit--;
+ db->addr = addr & ~LINE_SIZE_MASK;
+ remque (db); /* Off the free list */
+ insque (db, &dcache_valid); /* On the valid list */
+ }
+ return (dcache_value (db, addr));
+}
+
+/* Write the word at ADDR both in the data cache and in the remote machine. */
+static void
+dcache_poke (addr, data)
+ CORE_ADDR addr;
+ int data;
+{
+ register struct dcache_block *db;
+
+ /* First make sure the word is IN the cache. DB is its cache block. */
+ db = dcache_hit (addr);
+ if (db == 0)
+ {
+ db = dcache_alloc ();
+ immediate_quit++;
+ bug_write_inferior_memory (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
+ immediate_quit--;
+ db->addr = addr & ~LINE_SIZE_MASK;
+ remque (db); /* Off the free list */
+ insque (db, &dcache_valid); /* On the valid list */
+ }
+
+ /* Modify the word in the cache. */
+ db->data[XFORM (addr)] = data;
+
+ /* Send the changed word. */
+ immediate_quit++;
+ bug_write_inferior_memory (addr, (unsigned char *) &data, 4);
+ immediate_quit--;
+}
+
+/* The cache itself. */
+struct dcache_block the_cache[DCACHE_SIZE];
+
+/* Initialize the data cache. */
+static void
+dcache_init ()
+{
+ register i;
+ register struct dcache_block *db;
+
+ db = the_cache;
+ dcache_free.next = dcache_free.last = &dcache_free;
+ dcache_valid.next = dcache_valid.last = &dcache_valid;
+ for (i = 0; i < DCACHE_SIZE; i++, db++)
+ insque (db, &dcache_free);
+}
+
+/***********************************************************************
+ * I/O stuff stolen from remote-eb.c
+ ***********************************************************************/
+
+static int timeout = 2;
+
+static const char *dev_name;
+
+/* Descriptor for I/O to remote machine. Initialize it to -1 so that
+ bug_open knows that we don't have a file open when the program
+ starts. */
+
+int is_open = 0;
+int
+check_open ()
+{
+ if (!is_open)
+ {
+ error ("remote device not open");
+ }
+}
+
+#define ON 1
+#define OFF 0
+
+/* Read a character from the remote system, doing all the fancy
+ timeout stuff. */
+static int
+readchar ()
+{
+ int buf;
+
+ buf = SERIAL_READCHAR (desc, timeout);
+
+ if (buf == SERIAL_TIMEOUT)
+ error ("Timeout reading from remote system.");
+
+ if (!quiet)
+ printf ("%c", buf);
+
+ return buf & 0x7f;
+}
+
+static int
+readchar_nofail ()
+{
+ int buf;
+
+ buf = SERIAL_READCHAR (desc, timeout);
+ if (buf == SERIAL_TIMEOUT)
+ buf = 0;
+ if (!quiet)
+ printf ("%c", buf);
+
+ return buf & 0x7f;
+
+}
+
+/* Keep discarding input from the remote system, until STRING is found.
+ Let the user break out immediately. */
+static void
+expect (string)
+ char *string;
+{
+ char *p = string;
+
+ immediate_quit = 1;
+ while (1)
+ {
+ if (readchar () == *p)
+ {
+ p++;
+ if (*p == '\0')
+ {
+ immediate_quit = 0;
+ return;
+ }
+ }
+ else
+ p = string;
+ }
+}
+
+/* Keep discarding input until we see the bug prompt.
+
+ The convention for dealing with the prompt is that you
+ o give your command
+ o *then* wait for the prompt.
+
+ Thus the last thing that a procedure does with the serial line
+ will be an expect_prompt(). Exception: bug_resume does not
+ wait for the prompt, because the terminal is being handed over
+ to the inferior. However, the next thing which happens after that
+ is a bug_wait which does wait for the prompt.
+ Note that this includes abnormal exit, e.g. error(). This is
+ necessary to prevent getting into states from which we can't
+ recover. */
+static void
+expect_prompt ()
+{
+ expect ("Bug>");
+}
+
+/* Get a hex digit from the remote system & return its value.
+ If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
+static int
+get_hex_digit (ignore_space)
+ int ignore_space;
+{
+ int ch;
+
+ while (1)
+ {
+ ch = readchar ();
+ 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;
+ else if (ch == ' ' && ignore_space)
+ ;
+ else
+ {
+ expect_prompt ();
+ error ("Invalid hex digit from remote system.");
+ }
+ }
+}
+
+/* Get a byte from bug_desc and put it in *BYT. Accept any number
+ leading spaces. */
+static void
+get_hex_byte (byt)
+ char *byt;
+{
+ int val;
+
+ val = get_hex_digit (1) << 4;
+ val |= get_hex_digit (0);
+ *byt = val;
+}
+
+/* Read a 32-bit hex word from the bug, preceded by a space */
+static long
+get_hex_word ()
+{
+ long val;
+ int j;
+
+ val = 0;
+ for (j = 0; j < 8; j++)
+ val = (val << 4) + get_hex_digit (j == 0);
+ return val;
+}
+
+/* Called when SIGALRM signal sent due to alarm() timeout. */
+
+/* Number of SIGTRAPs we need to simulate. That is, the next
+ NEED_ARTIFICIAL_TRAP calls to bug_wait should just return
+ SIGTRAP without actually waiting for anything. */
+
+static int need_artificial_trap = 0;
+
+void
+bug_kill (arg, from_tty)
+ char *arg;
+ int from_tty;
+{
+
+}
+
+/*
+ * Download a file specified in 'args', to the bug.
+ */
+static void
+bug_load (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ bfd *abfd;
+ asection *s;
+ int n;
+ char buffer[1024];
+
+ check_open ();
+
+ dcache_flush ();
+ inferior_pid = 0;
+ abfd = bfd_openr (args, 0);
+ if (!abfd)
+ {
+ printf_filtered ("Unable to open file %s\n", args);
+ return;
+ }
+
+ if (bfd_check_format (abfd, bfd_object) == 0)
+ {
+ printf_filtered ("File is not an object file\n");
+ return;
+ }
+
+ s = abfd->sections;
+ while (s != (asection *) NULL)
+ {
+ if (s->flags & SEC_LOAD)
+ {
+ int i;
+
+#define DELTA (1024)
+ char *buffer = xmalloc (DELTA);
+
+ printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, s->vma, s->vma + s->_raw_size);
+ for (i = 0; i < s->_raw_size; i += DELTA)
+ {
+ int delta = DELTA;
+
+ if (delta > s->_raw_size - i)
+ delta = s->_raw_size - i;
+
+ bfd_get_section_contents (abfd, s, buffer, i, delta);
+ bug_write_inferior_memory (s->vma + i, buffer, delta);
+ printf_filtered ("*");
+ fflush (stdout);
+ }
+ printf_filtered ("\n");
+ free (buffer);
+ }
+ s = s->next;
+ }
+ sprintf (buffer, "rs ip %x", abfd->start_address);
+ bug_write_cr (buffer);
+ expect_prompt ();
+}
+
+/* This is called not only when we first attach, but also when the
+ user types "run" after having attached. */
+void
+bug_create_inferior (execfile, args, env)
+ char *execfile;
+ char *args;
+ char **env;
+{
+ int entry_pt;
+ char buffer[100];
+
+ if (args && *args)
+ error ("Can't pass arguments to remote bug process.");
+
+ if (execfile == 0 || exec_bfd == 0)
+ error ("No exec file specified");
+
+ entry_pt = (int) bfd_get_start_address (exec_bfd);
+ check_open ();
+
+ bug_kill (NULL, NULL);
+ bug_clear_breakpoints ();
+ init_wait_for_inferior ();
+ bug_write_cr ("");
+ expect_prompt ();
+
+ insert_breakpoints (); /* Needed to get correct instruction in cache */
+ proceed (entry_pt, -1, 0);
+}
+
+/* Open a connection to a remote debugger.
+ NAME is the filename used for communication, then a space,
+ then the baud rate.
+ */
+
+static char *
+find_end_of_word (s)
+ char *s;
+{
+ while (*s && !isspace (*s))
+ s++;
+ return s;
+}
+
+static char *
+get_word (p)
+ char **p;
+{
+ char *s = *p;
+ char *word;
+ char *copy;
+ size_t len;
+
+ while (isspace (*s))
+ s++;
+
+ word = s;
+
+ len = 0;
+
+ while (*s && !isspace (*s))
+ {
+ s++;
+ len++;
+
+ }
+ copy = xmalloc (len + 1);
+ memcpy (copy, word, len);
+ copy[len] = 0;
+ *p = s;
+ return copy;
+}
+
+static int baudrate = 9600;
+
+#if 0
+static int
+is_baudrate_right ()
+{
+ int ok;
+
+ /* Put this port into NORMAL mode, send the 'normal' character */
+
+ bug_write ("\001", 1); /* Control A */
+ bug_write ("\r", 1); /* Cr */
+
+ while (1)
+ {
+ ok = SERIAL_READCHAR (desc, timeout);
+ if (ok < 0)
+ break;
+ }
+
+ bug_write ("r", 1);
+
+ if (readchar_nofail () == 'r')
+ return 1;
+
+ /* Not the right baudrate, or the board's not on */
+ return 0;
+}
+#endif /* not */
+
+static void
+set_rate ()
+{
+ if (!SERIAL_SETBAUDRATE (desc, baudrate))
+ error ("Can't set baudrate");
+}
+
+
+static void
+bug_open (name, from_tty)
+ char *name;
+ int from_tty;
+{
+ unsigned int prl;
+ char *p;
+
+ push_target (&bug_ops);
+
+ if (name == 0)
+ {
+ name = "";
+ }
+ if (is_open)
+ bug_close (0);
+ dev_name = strdup (name);
+
+ if (!(desc = SERIAL_OPEN (dev_name)))
+ perror_with_name ((char *) dev_name);
+
+ SERIAL_RAW (desc);
+ is_open = 1;
+
+ dcache_init ();
+
+ /* Hello? Are you there? */
+ SERIAL_WRITE (desc, "\r", 1);
+ expect_prompt ();
+
+ /* Clear any break points */
+ bug_clear_breakpoints ();
+
+ printf_filtered ("Connected to remote 187bug system.\n");
+}
+
+/* Close out all files and local state before this target loses control. */
+
+static void
+bug_close (quitting)
+ int quitting;
+{
+ /* Clear any break points */
+ bug_clear_breakpoints ();
+
+ if (is_open)
+ SERIAL_CLOSE (desc);
+
+ is_open = 0;
+}
+
+/* Terminate the open connection to the remote debugger.
+ Use this when you want to detach and do something else
+ with your gdb. */
+void
+bug_detach (args, from_tty)
+ char *args;
+ int from_tty;
+{
+ if (is_open)
+ bug_clear_breakpoints ();
+
+ pop_target (); /* calls bug_close to do the real work */
+
+ if (from_tty)
+ printf_filtered ("Ending remote %s debugging\n", target_shortname);
+}
+
+/* Tell the remote machine to resume. */
+
+void
+bug_resume (step, sig)
+ int step, sig;
+{
+ dcache_flush ();
+
+ if (step)
+ {
+ bug_write_cr("t");
+
+ /* Force the next bug_wait to return a trap. Not doing anything
+ about I/O from the target means that the user has to type
+ "continue" to see any. FIXME, this should be fixed. */
+ need_artificial_trap = 1;
+ }
+ else
+ bug_write_cr ("g");
+
+ return;
+}
+
+/* Wait until the remote machine stops, then return,
+ storing status in STATUS just as `wait' would. */
+
+int
+not_bug_wait (status)
+ WAITTYPE *status;
+{
+ int old_timeout;
+ int old_quit;
+ int i;
+
+ expect("Effective address: ");
+ i = get_hex_word();
+ expect("\r");
+
+ WSETEXIT ((*status), 0);
+
+ old_timeout = timeout;
+ timeout = 99999; /* while user program runs. */
+ old_quit = immediate_quit;
+ immediate_quit = 1; /* helps ability to quit. */
+
+ while (strchr("\n\r", i = readchar()) != NULL) ;;
+
+ immediate_quit = old_quit;
+ timeout = old_timeout;
+
+ if (i == 'A')
+ {
+/* At Breakpoint */
+ expect("t Breakpoint");
+ WSETSTOP ((*status), SIGTRAP);
+
+ }
+ else
+ {
+/* finished cleanly */
+ ;
+ }
+
+ expect_prompt();
+}
+
+int
+bug_wait (status)
+ WAITTYPE *status;
+{
+ /* Strings to look for. '?' means match any single character.
+ Note that with the algorithm we use, the initial character
+ of the string cannot recur in the string, or we will not
+ find some cases of the string in the input. */
+
+ static char bpt[] = "At Breakpoint";
+ static char exitmsg[] = "????-Bug>";
+ char *bp = bpt;
+ char *ep = exitmsg;
+
+ /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
+ char swallowed[50];
+
+ /* Current position in swallowed. */
+ char *swallowed_p = swallowed;
+
+ int ch;
+ int ch_handled;
+ int old_timeout = timeout;
+ int old_immediate_quit = immediate_quit;
+ int swallowed_cr = 0;
+
+ WSETEXIT ((*status), 0);
+
+ if (need_artificial_trap != 0)
+ {
+ WSETSTOP ((*status), SIGTRAP);
+ need_artificial_trap--;
+ /* user output from the target can be discarded here. (?) */
+ expect_prompt();
+ return 0;
+ }
+
+ /* read off leftovers from resume */
+ expect("Effective address: ");
+ (void) get_hex_word();
+ while (strchr("\r\n", ch = readchar()) != NULL) ;;
+
+ timeout = 99999; /* Don't time out -- user program is running. */
+ immediate_quit = 1; /* Helps ability to QUIT */
+ while (1)
+ {
+ QUIT; /* Let user quit and leave process running */
+ ch_handled = 0;
+ if (ch == *bp)
+ {
+ bp++;
+ if (*bp == '\0')
+ break;
+ ch_handled = 1;
+
+ *swallowed_p++ = ch;
+ }
+ else
+ {
+ bp = bpt;
+ }
+ if (ch == *ep || *ep == '?')
+ {
+ ep++;
+ if (*ep == '\0')
+ break;
+
+ if (!ch_handled)
+ *swallowed_p++ = ch;
+ ch_handled = 1;
+ }
+ else
+ {
+ ep = exitmsg;
+ }
+
+ if (!ch_handled)
+ {
+ char *p;
+
+ /* Print out any characters which have been swallowed. */
+ for (p = swallowed; p < swallowed_p; ++p)
+ putc (*p, stdout);
+ swallowed_p = swallowed;
+
+ if ((ch != '\r' && ch != '\n') || swallowed_cr > 10)
+ {
+ putc (ch, stdout);
+ swallowed_cr = 10;
+ }
+ swallowed_cr++;
+
+ }
+
+ ch = readchar ();
+ }
+ if (*bp == '\0')
+ {
+ WSETSTOP ((*status), SIGTRAP);
+ expect_prompt ();
+ }
+ else
+ {
+ WSETEXIT ((*status), 0);
+ }
+
+ timeout = old_timeout;
+ immediate_quit = old_immediate_quit;
+ return 0;
+}
+
+/* Return the name of register number REGNO
+ in the form input and output by bug.
+
+ Returns a pointer to a static buffer containing the answer. */
+static char *
+get_reg_name (regno)
+ int regno;
+{
+ static char *rn[] = {
+ "r00", "r01", "r02", "r03", "r04", "r05", "r06", "r07",
+ "r08", "r09", "r10", "r11", "r12", "r13", "r14", "r15",
+ "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
+ "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
+
+ /* these get confusing because we omit a few and switch some ordering around. */
+
+ "cr01", /* 32 = psr */
+ "fcr62", /* 33 = fpsr*/
+ "fcr63", /* 34 = fpcr */
+ "cr04", /* 35 = sxip */
+ "cr05", /* 36 = snip */
+ "cr06", /* 37 = sfip */
+ };
+
+ return rn[regno];
+}
+
+static int
+gethex (length, start, ok)
+ unsigned int length;
+ char *start;
+ int *ok;
+{
+ int result = 0;
+
+ while (length--)
+ {
+ result <<= 4;
+ if (*start >= 'a' && *start <= 'f')
+ {
+ result += *start - 'a' + 10;
+ }
+ else if (*start >= 'A' && *start <= 'F')
+ {
+ result += *start - 'A' + 10;
+ }
+ else if (*start >= '0' && *start <= '9')
+ {
+ result += *start - '0';
+ }
+ else
+ *ok = 0;
+ start++;
+
+ }
+ return result;
+}
+static int
+timed_read (buf, n, timeout)
+ char *buf;
+
+{
+ int i;
+ char c;
+
+ i = 0;
+ while (i < n)
+ {
+ c = readchar ();
+
+ if (c == 0)
+ return i;
+ buf[i] = c;
+ i++;
+
+ }
+ return i;
+}
+
+bug_write (a, l)
+ char *a;
+{
+ int i;
+
+ SERIAL_WRITE (desc, a, l);
+
+ if (!quiet)
+ for (i = 0; i < l; i++)
+ {
+ printf ("%c", a[i]);
+ }
+}
+
+bug_write_cr (s)
+ char *s;
+{
+ bug_write (s, strlen (s));
+ bug_write ("\r", 1);
+}
+
+/* Store register REGNO, or all if REGNO == -1. */
+
+static void
+bug_fetch_register(regno)
+ int regno;
+{
+ REGISTER_TYPE regval;
+ check_open();
+
+ if (regno == -1)
+ {
+ int i;
+
+ for (i = 0; i < NUM_REGS; ++i)
+ bug_fetch_register(i);
+ }
+ else
+ {
+ bug_write("rs ", 3);
+ bug_write_cr(get_reg_name(regno));
+ expect("=");
+ regval = get_hex_word();
+ expect_prompt();
+
+ /* the following registers contain flag bits in the lower to bit slots.
+ Mask them off */
+ if (regno == PC_REGNUM /* aka sxip */
+ || regno == NPC_REGNUM /* aka snip */
+ || regno == SFIP_REGNUM) /* aka sfip */
+ regval &= ~0x3;
+
+ supply_register(regno, (char *) ®val);
+ }
+
+ return;
+}
+
+/* Store register REGNO, or all if REGNO == -1. */
+
+static void
+bug_store_register (regno)
+ int regno;
+{
+ REGISTER_TYPE regval;
+ char buffer[1024];
+ check_open();
+
+ if (regno == -1)
+ {
+ int i;
+
+ for (i = 0; i < NUM_REGS; ++i)
+ bug_store_register(i);
+ }
+ else
+ {
+ char *regname;
+
+ /* get_reg_name thinks that the pc is in sxip. This is only partially
+ true. When *assigning* it, we must assign to ip on m88k-bug. */
+
+ regname = ((regno == PC_REGNUM)
+ ? "ip"
+ : get_reg_name(regno));
+
+ sprintf(buffer, "rs %s %08x",
+ regname,
+ read_register(regno));
+
+ bug_write_cr(buffer);
+ expect_prompt();
+ }
+
+ return;
+}
+
+/* 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. */
+
+void
+bug_prepare_to_store ()
+{
+ /* Do nothing, since we can store individual regs */
+}
+
+static CORE_ADDR
+translate_addr (addr)
+ CORE_ADDR addr;
+{
+
+ return (addr);
+
+}
+
+/* Read a word from remote address ADDR and return it.
+ * This goes through the data cache.
+ */
+int
+bug_fetch_word (addr)
+ CORE_ADDR addr;
+{
+ return dcache_fetch (addr);
+}
+
+/* Write a word WORD into remote address ADDR.
+ This goes through the data cache. */
+
+void
+bug_store_word (addr, word)
+ CORE_ADDR addr;
+ int word;
+{
+ dcache_poke (addr, word);
+}
+
+int
+bug_xfer_inferior_memory (memaddr, myaddr, len, write, target)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int write;
+ struct target_ops *target; /* ignored */
+{
+ register int i;
+
+ /* Round starting address down to longword boundary. */
+ register CORE_ADDR addr;
+
+ /* Round ending address up; get number of longwords that makes. */
+ register int count;
+
+ /* Allocate buffer of that many longwords. */
+ register int *buffer;
+
+ addr = memaddr & -sizeof (int);
+ count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+
+ buffer = (int *) alloca (count * sizeof (int));
+
+ if (write)
+ {
+ /* Fill start and end extra bytes of buffer with existing memory data. */
+
+ if (addr != memaddr || len < (int) sizeof (int))
+ {
+ /* Need part of initial word -- fetch it. */
+ buffer[0] = bug_fetch_word (addr);
+ }
+
+ if (count > 1) /* FIXME, avoid if even boundary */
+ {
+ buffer[count - 1]
+ = bug_fetch_word (addr + (count - 1) * sizeof (int));
+ }
+
+ /* Copy data to be written over corresponding part of buffer */
+
+ bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+
+ /* Write the entire buffer. */
+
+ for (i = 0; i < count; i++, addr += sizeof (int))
+ {
+ errno = 0;
+ bug_store_word (addr, buffer[i]);
+ if (errno)
+ {
+
+ return 0;
+ }
+
+ }
+ }
+ else
+ {
+ /* Read all the longwords */
+ for (i = 0; i < count; i++, addr += sizeof (int))
+ {
+ errno = 0;
+ buffer[i] = bug_fetch_word (addr);
+ if (errno)
+ {
+ return 0;
+ }
+ QUIT;
+ }
+
+ /* Copy appropriate bytes out of the buffer. */
+ bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+ }
+
+ return len;
+}
+
+/* fixme: make this user settable */
+#define CHUNK_SIZE (30)
+
+int
+bug_write_inferior_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ unsigned char *myaddr;
+ int len;
+{
+ int done;
+ int todo;
+ int checksum;
+ char buffer[(CHUNK_SIZE + 8) << 1];
+
+ done = 0;
+
+#define LOAD_COMMAND "lo 0"
+ bug_write_cr (LOAD_COMMAND);
+
+ while (done < len)
+ {
+ int thisgo;
+ int idx;
+ char *buf = buffer;
+ CORE_ADDR address;
+
+ checksum = 0;
+ thisgo = len - done;
+ if (thisgo > CHUNK_SIZE)
+ thisgo = CHUNK_SIZE;
+
+ address = memaddr + done;
+ sprintf (buf, "S3%02X%08X", thisgo + 4 + 1, address);
+ buf += 12;
+
+ checksum += (thisgo + 4 + 1
+ + (address & 0xff)
+ + ((address >> 8) & 0xff)
+ + ((address >> 16) & 0xff)
+ + ((address >> 24) & 0xff));
+
+ for (idx = 0; idx < thisgo; idx++)
+ {
+ sprintf (buf, "%02X", myaddr[idx + done]);
+ checksum += myaddr[idx + done];
+ buf += 2;
+ }
+ sprintf(buf, "%02X", ~checksum & 0xff);
+ bug_write_cr (buffer);
+ done += thisgo;
+ }
+
+ bug_write_cr("S7060000000000F9");
+ expect_prompt();
+}
+
+void
+bug_files_info ()
+{
+ char *file = "nothing";
+
+ if (exec_bfd)
+ file = bfd_get_filename (exec_bfd);
+
+ if (exec_bfd)
+#ifdef __GO32__
+ printf_filtered ("\tAttached to DOS asynctsr and running program %s\n", file);
+#else
+ printf_filtered ("\tAttached to %s at %d baud and running program %s\n", dev_name, baudrate, file);
+#endif
+ printf_filtered ("\ton an m88k processor.\n");
+}
+
+/* Copy LEN bytes of data from debugger memory at MYADDR
+ to inferior's memory at MEMADDR. Returns errno value.
+ * sb/sh instructions don't work on unaligned addresses, when TU=1.
+ */
+
+/* Read LEN bytes from inferior memory at MEMADDR. Put the result
+ at debugger address MYADDR. Returns errno value. */
+int
+bug_read_inferior_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ char request[100];
+ char *buffer;
+ char *p;
+ char type;
+ char size;
+ unsigned char c;
+ unsigned int inaddr;
+ unsigned int checksum;
+
+ sprintf(request, "du 0 %x:&%d", memaddr, len);
+ bug_write_cr(request);
+
+ p = buffer = alloca(len);
+
+ /* scan up through the header */
+ expect("S0030000FC");
+
+ while (p < buffer + len)
+ {
+ /* scan off any white space. */
+ while (readchar() != 'S') ;;
+
+ /* what kind of s-rec? */
+ type = readchar();
+
+ /* scan record size */
+ get_hex_byte(&size);
+ checksum = size;
+ --size;
+ inaddr = 0;
+
+ switch (type)
+ {
+ case '7':
+ case '8':
+ case '9':
+ goto done;
+
+ case '3':
+ get_hex_byte(&c);
+ inaddr = (inaddr << 8) + c;
+ checksum += c;
+ --size;
+ /* intentional fall through */
+ case '2':
+ get_hex_byte(&c);
+ inaddr = (inaddr << 8) + c;
+ checksum += c;
+ --size;
+ /* intentional fall through */
+ case '1':
+ get_hex_byte(&c);
+ inaddr = (inaddr << 8) + c;
+ checksum += c;
+ --size;
+ get_hex_byte(&c);
+ inaddr = (inaddr << 8) + c;
+ checksum += c;
+ --size;
+ break;
+
+ default:
+ /* bonk */
+ error("reading s-records.");
+ }
+
+ if (inaddr < memaddr
+ || (memaddr + len) < (inaddr + size))
+ error("srec out of memory range.");
+
+ if (p != buffer + inaddr - memaddr)
+ error("srec out of sequence.");
+
+ for (; size; --size, ++p)
+ {
+ get_hex_byte(p);
+ checksum += *p;
+ }
+
+ get_hex_byte(&c);
+ if (c != (~checksum & 0xff))
+ error("bad s-rec checksum");
+ }
+
+ done:
+ expect_prompt();
+ if (p != buffer + len)
+ return(1);
+
+ memcpy(myaddr, buffer, len);
+ return(0);
+}
+
+/* This routine is run as a hook, just before the main command loop is
+ entered. If gdb is configured for the H8, but has not had its
+ target specified yet, this will loop prompting the user to do so.
+*/
+
+bug_before_main_loop ()
+{
+ char ttyname[100];
+ char *p, *p2;
+ extern FILE *instream;
+
+ push_target (&bug_ops);
+}
+
+#define MAX_BREAKS 16
+static int num_brkpts = 0;
+static int
+bug_insert_breakpoint (addr, save)
+ CORE_ADDR addr;
+ char *save; /* Throw away, let bug save instructions */
+{
+ check_open ();
+
+ if (num_brkpts < MAX_BREAKS)
+ {
+ char buffer[100];
+
+ num_brkpts++;
+ sprintf (buffer, "br %x", addr);
+ bug_write_cr (buffer);
+ expect_prompt ();
+ return(0);
+ }
+ else
+ {
+ fprintf_filtered (stderr,
+ "Too many break points, break point not installed\n");
+ return(1);
+ }
+
+}
+static int
+bug_remove_breakpoint (addr, save)
+ CORE_ADDR addr;
+ char *save; /* Throw away, let bug save instructions */
+{
+ if (num_brkpts > 0)
+ {
+ char buffer[100];
+
+ num_brkpts--;
+ sprintf (buffer, "nobr %x", addr);
+ bug_write_cr (buffer);
+ expect_prompt ();
+
+ }
+ return (0);
+}
+
+/* Clear the bugs notion of what the break points are */
+static int
+bug_clear_breakpoints ()
+{
+
+ if (is_open)
+ {
+ bug_write_cr ("nobr");
+ expect_prompt ();
+ }
+ num_brkpts = 0;
+}
+static void
+bug_mourn ()
+{
+ bug_clear_breakpoints ();
+ generic_mourn_inferior ();
+}
+
+/* Put a command string, in args, out to the bug. The bug is assumed to
+ be in raw mode, all writing/reading done through desc.
+ Ouput from the bug is placed on the users terminal until the
+ prompt from the bug is seen.
+ FIXME: Can't handle commands that take input. */
+
+void
+bug_com (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ check_open ();
+
+ if (!args)
+ return;
+
+ /* Clear all input so only command relative output is displayed */
+
+ bug_write_cr (args);
+ bug_write ("\030", 1);
+ expect_prompt ();
+}
+
+bug_quiet ()
+{
+ quiet = !quiet;
+ if (quiet)
+ printf_filtered ("Snoop disabled\n");
+ else
+ printf_filtered ("Snoop enabled\n");
+
+}
+
+bug_device (s)
+ char *s;
+{
+ if (s)
+ {
+ dev_name = get_word (&s);
+ }
+}
+
+#if 0
+static
+bug_speed (s)
+ char *s;
+{
+ check_open ();
+
+ if (s)
+ {
+ char buffer[100];
+ int newrate = atoi (s);
+ int which = 0;
+
+ if (SERIAL_SETBAUDRATE (desc, newrate))
+ error ("Can't use %d baud\n", newrate);
+
+ printf_filtered ("Checking target is in sync\n");
+
+ printf_filtered ("Sending commands to set target to %d\n",
+ baudrate);
+
+ sprintf (buffer, "tm %d. N 8 1", baudrate);
+ bug_write_cr (buffer);
+ }
+}
+#endif /* 0 */
+
+static struct target_ops bug_ops =
+{
+ "bug", "Remote BUG monitor",
+ "Use the mvme187 board running the BUG monitor connected\n\
+by a serial line.",
+
+ bug_open, bug_close,
+ 0, bug_detach, bug_resume, bug_wait, /* attach */
+ bug_fetch_register, bug_store_register,
+ bug_prepare_to_store,
+ bug_xfer_inferior_memory,
+ bug_files_info,
+ bug_insert_breakpoint, bug_remove_breakpoint, /* Breakpoints */
+ 0, 0, 0, 0, 0, /* Terminal handling */
+ bug_kill, /* FIXME, kill */
+ bug_load,
+ 0, /* lookup_symbol */
+ bug_create_inferior, /* create_inferior */
+ bug_mourn, /* mourn_inferior FIXME */
+ 0, /* can_run */
+ 0, /* notice_signals */
+ 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 */
+};
+
+void
+_initialize_remote_bug ()
+{
+ add_target (&bug_ops);
+
+ add_com ("bug <command>", class_obscure, bug_com,
+ "Send a command to the BUG monitor.");
+ add_com ("snoop", class_obscure, bug_quiet,
+ "Show what commands are going to the monitor");
+
+ add_com ("device", class_obscure, bug_device,
+ "Set the terminal line for BUG communications");
+
+#if 0
+ add_com ("speed", class_obscure, bug_speed,
+ "Set the terminal line speed for BUG communications");
+#endif /* 0 */
+
+ dev_name = NULL;
+}
projects / platform / upstream / binutils.git / commitdiff