/* Remote debugging interface for boot monitors, for GDB.
- Copyright 1990, 1991, 1992, 1993, 1995 Free Software Foundation, Inc.
- Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
+ Copyright 1990, 1991, 1992, 1993, 1995, 1996
+ Free Software Foundation, Inc.
+ Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
+ Resurrected from the ashes by Stu Grossman.
This file is part of GDB.
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. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* This file was derived from various remote-* modules. It is a collection
of generic support functions so GDB can talk directly to a ROM based
(or possibly TELNET) stream to a terminal multiplexor,
which in turn talks to the target board. */
+/* FIXME 32x64: This code assumes that registers and addresses are at
+ most 32 bits long. If they can be larger, you will need to declare
+ values as LONGEST and use %llx or some such to print values when
+ building commands to send to the monitor. Since we don't know of
+ any actual 64-bit targets with ROM monitors that use this code,
+ it's not an issue right now. -sts 4/18/96 */
+
#include "defs.h"
#include "gdbcore.h"
#include "target.h"
#include <varargs.h>
#endif
#include <signal.h>
-#include <string.h>
+#include <ctype.h>
+#include "gdb_string.h"
#include <sys/types.h>
#include "command.h"
#include "serial.h"
#include "monitor.h"
#include "gdbcmd.h"
#include "inferior.h"
-#include "regex.h"
+#include "gnu-regex.h"
+#include "dcache.h"
+#include "srec.h"
+
+static char *dev_name;
+static struct target_ops *targ_ops;
static int readchar PARAMS ((int timeout));
static void monitor_command PARAMS ((char *args, int fromtty));
-static void monitor_load_srec PARAMS ((char *args));
-
-static int monitor_make_srec PARAMS ((char *buffer, int type,
- CORE_ADDR memaddr,
- unsigned char *myaddr, int len));
static void monitor_fetch_register PARAMS ((int regno));
static void monitor_store_register PARAMS ((int regno));
-static void monitor_close PARAMS ((int quitting));
static void monitor_detach PARAMS ((char *args, int from_tty));
static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
static void monitor_interrupt PARAMS ((int signo));
static void monitor_load PARAMS ((char *file, int from_tty));
static void monitor_mourn_inferior PARAMS ((void));
static void monitor_stop PARAMS ((void));
+static void monitor_debug PARAMS ((char *prefix, char *string, char *suffix));
+
+static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
+static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
+static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat,
+ char *buf, int buflen));
static int from_hex PARAMS ((int a));
static unsigned long get_hex_word PARAMS ((void));
/* Pointer to regexp pattern matching data */
static struct re_pattern_buffer register_pattern;
+static char register_fastmap[256];
-/* Element 0 points to start of register name, and element 1 points to the
- start of the register value. */
-
-static struct re_registers register_strings;
-
-static char fastmap[256];
+static struct re_pattern_buffer getmem_resp_delim_pattern;
+static char getmem_resp_delim_fastmap[256];
static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
monitor_wait wakes up. */
+static DCACHE *remote_dcache;
+static int first_time=0; /* is this the first time we're executing after
+ gaving created the child proccess? */
+
+/* monitor_debug is like fputs_unfiltered, except it prints special
+ characters in printable fashion. */
+
+static void
+monitor_debug (prefix, string, suffix)
+ char *prefix;
+ char *string;
+ char *suffix;
+{
+ int ch;
+
+ /* print prefix and suffix after each line */
+ static int new_line=1;
+ static char *prev_prefix = "";
+ static char *prev_suffix = "";
+
+ /* if the prefix is changing, print the previous suffix, a new line,
+ and the new prefix */
+ if (strcmp(prev_prefix, prefix) != 0 && !new_line)
+ {
+ fputs_unfiltered (prev_suffix, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ fputs_unfiltered (prefix, gdb_stderr);
+ }
+ prev_prefix = prefix;
+ prev_suffix = suffix;
+
+ /* print prefix if last char was a newline*/
+
+ if (new_line == 1) {
+ fputs_unfiltered (prefix, gdb_stderr);
+ new_line=0;
+ }
+ if (strchr(string,'\n')) /* save state for next call */
+ new_line=1;
+
+ while ((ch = *string++) != '\0')
+ {
+ switch (ch) {
+ default:
+ if (isprint (ch))
+ fputc_unfiltered (ch, gdb_stderr);
+
+ else
+ fprintf_unfiltered (gdb_stderr, "\\%03o", ch);
+
+ break;
+
+ case '\\': fputs_unfiltered ("\\\\", gdb_stderr); break;
+ case '\b': fputs_unfiltered ("\\b", gdb_stderr); break;
+ case '\f': fputs_unfiltered ("\\f", gdb_stderr); break;
+ case '\n': fputs_unfiltered ("\\n", gdb_stderr); break;
+ case '\r': fputs_unfiltered ("\\r", gdb_stderr); break;
+ case '\t': fputs_unfiltered ("\\t", gdb_stderr); break;
+ case '\v': fputs_unfiltered ("\\v", gdb_stderr); break;
+ }
+ }
+
+ if (new_line==1) { /* print suffix if last char was a newline */
+ fputs_unfiltered (suffix, gdb_stderr);
+ fputs_unfiltered ("\n", gdb_stderr);
+ }
+}
+
/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
Works just like printf. */
vsprintf (sndbuf, pattern, args);
if (remote_debug > 0)
- fputs_unfiltered (sndbuf, gdb_stderr);
+ monitor_debug ("sent -->", sndbuf, "<--");
len = strlen (sndbuf);
va_list args;
char sndbuf[2000];
int len;
- int i, c;
#ifdef ANSI_PROTOTYPES
va_start (args, pattern);
vsprintf (sndbuf, pattern, args);
if (remote_debug > 0)
- fputs_unfiltered (sndbuf, gdb_stderr);
+ monitor_debug ("sent -->", sndbuf, "<--");
len = strlen (sndbuf);
if (SERIAL_WRITE(monitor_desc, sndbuf, len))
fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
- for (i = 0; i < len; i++)
- {
- trycr:
- c = readchar (timeout);
-
- if (c != sndbuf[i])
- {
-#if 0
- if (sndbuf[i] == '\r'
- && c == '\n')
- goto trycr;
-#endif
- error ("monitor_printf: Bad echo. Sent: \"%s\", Got: \"%.*s%c\".",
- sndbuf, i, sndbuf, c);
- }
- }
+ /* We used to expect that the next immediate output was the characters we
+ just output, but sometimes some extra junk appeared before the characters
+ we expected, like an extra prompt, or a portmaster sending telnet negotiations.
+ So, just start searching for what we sent, and skip anything unknown. */
+ monitor_expect (sndbuf, (char *)0, 0);
}
/* Read a character from the remote system, doing all the fancy
int timeout;
{
int c;
+ static enum { last_random, last_nl, last_cr, last_crnl } state = last_random;
+ int looping;
- c = SERIAL_READCHAR (monitor_desc, timeout);
+ do
+ {
+ looping = 0;
+ c = SERIAL_READCHAR (monitor_desc, timeout);
- if (remote_debug > 0)
- fputc_unfiltered (c, gdb_stderr);
+ if (c >= 0)
+ {
+ c &= 0x7f;
+ if (remote_debug > 0)
+ {
+ char buf[2];
+ buf[0] = c;
+ buf[1] = '\0';
+ monitor_debug ("read -->", buf, "<--");
+ }
+ }
+
+ /* Canonicialize \n\r combinations into one \r */
+ if ((current_monitor->flags & MO_HANDLE_NL) != 0)
+ {
+ if ((c == '\r' && state == last_nl)
+ || (c == '\n' && state == last_cr))
+ {
+ state = last_crnl;
+ looping = 1;
+ }
+ else if (c == '\r')
+ state = last_cr;
+ else if (c != '\n')
+ state = last_random;
+ else
+ {
+ state = last_nl;
+ c = '\r';
+ }
+ }
+ }
+ while (looping);
if (c >= 0)
- return c & 0x7f;
+ return c;
if (c == SERIAL_TIMEOUT)
#ifdef MAINTENANCE_CMDS
char *p = string;
int obuflen = buflen;
int c;
+ extern struct target_ops *targ_ops;
immediate_quit = 1;
while (1)
}
c = readchar (timeout);
+ if (c == '\000')
+ continue;
*buf++ = c;
buflen--;
}
else
c = readchar (timeout);
- if (c == *p++)
+ /* Don't expect any ^C sent to be echoed */
+
+ if (*p == '\003' || c == *p)
{
+ p++;
if (*p == '\0')
{
immediate_quit = 0;
return 0;
}
}
+ else if ((c == '\021' || c == '\023') &&
+ (strcmp(targ_ops->to_shortname, "m32r") == 0))
+ { /* m32r monitor emits random DC1/DC3 chars */
+ continue;
+ }
else
{
p = string;
}
}
+/* Search for a regexp. */
+
+static int
+monitor_expect_regexp (pat, buf, buflen)
+ struct re_pattern_buffer *pat;
+ char *buf;
+ int buflen;
+{
+ char *mybuf;
+ char *p;
+
+ if (buf)
+ mybuf = buf;
+ else
+ {
+ mybuf = alloca (1024);
+ buflen = 1024;
+ }
+
+ p = mybuf;
+ while (1)
+ {
+ int retval;
+
+ if (p - mybuf >= buflen)
+ { /* Buffer about to overflow */
+
+/* On overflow, we copy the upper half of the buffer to the lower half. Not
+ great, but it usually works... */
+
+ memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
+ p = mybuf + buflen / 2;
+ }
+
+ *p++ = readchar (timeout);
+
+ retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
+ if (retval >= 0)
+ return 1;
+ }
+}
+
/* Keep discarding input until we see the MONITOR 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 monitor_expect_prompt(). Exception: monitor_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 monitor_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. */
+ Thus the last thing that a procedure does with the serial line will
+ be an monitor_expect_prompt(). Exception: monitor_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 monitor_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. */
int
monitor_expect_prompt (buf, buflen)
char *buf;
int buflen;
{
- return monitor_expect (PROMPT, buf, buflen);
+ return monitor_expect (current_monitor->prompt, buf, buflen);
}
/* Get N 32-bit words from remote, each preceded by a space, and put
return val;
}
+static void
+compile_pattern (pattern, compiled_pattern, fastmap)
+ char *pattern;
+ struct re_pattern_buffer *compiled_pattern;
+ char *fastmap;
+{
+ int tmp;
+ char *val;
+
+ compiled_pattern->fastmap = fastmap;
+
+ tmp = re_set_syntax (RE_SYNTAX_EMACS);
+ val = re_compile_pattern (pattern,
+ strlen (pattern),
+ compiled_pattern);
+ re_set_syntax (tmp);
+
+ if (val)
+ error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
+
+ if (fastmap)
+ re_compile_fastmap (compiled_pattern);
+}
+
/* Open a connection to a remote debugger. NAME is the filename used
for communication. */
-static char *dev_name;
-static struct target_ops *targ_ops;
-
void
monitor_open (args, mon_ops, from_tty)
char *args;
/* Setup pattern for register dump */
if (mon_ops->register_pattern)
- {
- int tmp;
- char *val;
-
- register_pattern.fastmap = fastmap;
- tmp = re_set_syntax (RE_SYNTAX_EMACS);
- val = re_compile_pattern (mon_ops->register_pattern,
- strlen (mon_ops->register_pattern),
- ®ister_pattern);
- re_set_syntax (tmp);
- if (val)
- error ("Can't compiler register pattern string: %s!", val);
- re_compile_fastmap (®ister_pattern);
- }
+ compile_pattern (mon_ops->register_pattern, ®ister_pattern,
+ register_fastmap);
+
+ if (mon_ops->getmem.resp_delim)
+ compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
+ getmem_resp_delim_fastmap);
unpush_target (targ_ops);
if (current_monitor->stop)
{
monitor_stop ();
- monitor_expect_prompt (NULL, 0);
+ if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
+ {
+ monitor_expect_prompt (NULL, 0);
+ }
}
/* wake up the monitor and see if it's alive */
for (p = mon_ops->init; *p != NULL; p++)
{
- monitor_printf (*p);
+ /* Some of the characters we send may not be echoed,
+ but we hope to get a prompt at the end of it all. */
+
+ if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
+ monitor_printf(*p);
+ else
+ monitor_printf_noecho (*p);
monitor_expect_prompt (NULL, 0);
}
monitor_printf (current_monitor->line_term);
+ remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
+
start_remote ();
}
/* Close out all files and local state before this target loses
control. */
-static void
+void
monitor_close (quitting)
int quitting;
{
int regno;
char *valstr;
{
- unsigned LONGEST val;
+ unsigned int val;
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
char *p;
int pid, step;
enum target_signal sig;
{
+ /* Some monitors require a different command when starting a program */
+ if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
+ {
+ first_time = 0;
+ monitor_printf ("run\r");
+ if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
+ dump_reg_flag = 1;
+ return;
+ }
+ dcache_flush (remote_dcache);
if (step)
- monitor_printf (STEP_CMD);
+ monitor_printf (current_monitor->step);
else
{
- monitor_printf (CONT_CMD);
+ monitor_printf (current_monitor->cont);
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
dump_reg_flag = 1;
}
}
-/* Parse the output of a register dump command. A monitor specific regexp is
- used to extract individual register descriptions of the form REG=VAL. Each
- description is split up into a name and a value string which are passed down
- to monitor specific code. */
+/* Parse the output of a register dump command. A monitor specific
+ regexp is used to extract individual register descriptions of the
+ form REG=VAL. Each description is split up into a name and a value
+ string which are passed down to monitor specific code. */
static char *
parse_register_dump (buf, len)
{
int regnamelen, vallen;
char *regname, *val;
+ /* Element 0 points to start of register name, and element 1
+ points to the start of the register value. */
+ struct re_registers register_strings;
if (re_search (®ister_pattern, buf, len, 0, len,
®ister_strings) == -1)
char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
int i;
- name = REGNAMES (regno);
+ name = current_monitor->regnames[regno];
if (!name)
{
return;
}
- /* send the register examine command */
+ /* send the register examine command */
monitor_printf (current_monitor->getreg.cmd, name);
-/* If RESP_DELIM is specified, we search for that as a leading delimiter for
- the register value. Otherwise, we just start searching from the start of
- the buf. */
+ /* If RESP_DELIM is specified, we search for that as a leading
+ delimiter for the register value. Otherwise, we just start
+ searching from the start of the buf. */
if (current_monitor->getreg.resp_delim)
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
-/* Now, read the appropriate number of hex digits for this register, skipping
- spaces. */
+ /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
+ if (current_monitor->flags & MO_HEX_PREFIX)
+ {
+ int c;
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
+ if ((c == '0') && ((c = readchar (timeout)) == 'x'))
+ ;
+ else
+ error ("Bad value returned from monitor while fetching register %x.",
+ regno);
+ }
+
+ /* Read upto the maximum number of hex digits for this register, skipping
+ spaces, but stop reading if something else is seen. Some monitors
+ like to drop leading zeros. */
for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
{
int c;
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
- while (1)
- {
- c = readchar (timeout);
- if (isxdigit (c))
- break;
- if (c == ' ')
- continue;
-
- error ("monitor_fetch_register (%d): bad response from monitor: %.*s%c.",
- regno, i, regbuf, c);
- }
+ if (!isxdigit (c))
+ break;
regbuf[i] = c;
}
regbuf[i] = '\000'; /* terminate the number */
-/* If TERM is present, we wait for that to show up. Also, (if TERM is
- present), we will send TERM_CMD if that is present. In any case, we collect
- all of the output into buf, and then wait for the normal prompt. */
+ /* If TERM is present, we wait for that to show up. Also, (if TERM
+ is present), we will send TERM_CMD if that is present. In any
+ case, we collect all of the output into buf, and then wait for
+ the normal prompt. */
if (current_monitor->getreg.term)
{
/* Read the remote registers into the block regs. */
+static void monitor_dump_regs ()
+{
+ char buf[1024];
+ int resp_len;
+
+ if (current_monitor->dump_registers)
+ {
+ monitor_printf (current_monitor->dump_registers);
+ resp_len = monitor_expect_prompt (buf, sizeof (buf));
+ parse_register_dump (buf, resp_len);
+ }
+ else
+ abort(); /* Need some way to read registers */
+}
+
static void
monitor_fetch_registers (regno)
int regno;
{
- if (regno >= 0)
+ if (current_monitor->getreg.cmd)
{
- monitor_fetch_register (regno);
- return;
- }
+ if (regno >= 0)
+ {
+ monitor_fetch_register (regno);
+ return;
+ }
- for (regno = 0; regno < NUM_REGS; regno++)
- monitor_fetch_register (regno);
+ for (regno = 0; regno < NUM_REGS; regno++)
+ monitor_fetch_register (regno);
+ }
+ else {
+ monitor_dump_regs ();
+ }
}
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
int regno;
{
char *name;
- unsigned LONGEST val;
+ unsigned int val;
- name = REGNAMES (regno);
+ name = current_monitor->regnames[regno];
if (!name)
return;
/* send the register deposit command */
- monitor_printf (current_monitor->setreg.cmd, name, val);
+ if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
+ monitor_printf (current_monitor->setreg.cmd, val, name);
+ else
+ monitor_printf (current_monitor->setreg.cmd, name, val);
-/* It's possible that there are actually some monitors out there that will
- prompt you when you set a register. In that case, you may need to add some
- code here to deal with TERM and TERM_CMD (see monitor_fetch_register to get
- an idea of what's needed...) */
+/* It's possible that there are actually some monitors out there that
+ will prompt you when you set a register. In that case, you may
+ need to add some code here to deal with TERM and TERM_CMD (see
+ monitor_fetch_register to get an idea of what's needed...) */
monitor_expect_prompt (NULL, 0);
}
static int
monitor_write_memory (memaddr, myaddr, len)
CORE_ADDR memaddr;
- unsigned char *myaddr;
+ char *myaddr;
int len;
{
- unsigned LONGEST val;
+ unsigned int val;
char *cmd;
int i;
}
}
+#if 0
+ /* Can't actually use long longs if VAL is an int (nice idea, though). */
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
{
len = 8;
cmd = current_monitor->setmem.cmdll;
}
- else if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
+ else
+#endif
+ if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
{
len = 4;
cmd = current_monitor->setmem.cmdl;
val = extract_unsigned_integer (myaddr, len);
- monitor_printf (cmd, memaddr, val);
+ if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
+ monitor_printf_noecho (cmd, memaddr, val);
+ else
+ monitor_printf (cmd, memaddr, val);
monitor_expect_prompt (NULL, 0);
static int
monitor_read_memory_single (memaddr, myaddr, len)
CORE_ADDR memaddr;
- unsigned char *myaddr;
+ char *myaddr;
int len;
{
- unsigned LONGEST val;
- char membuf[sizeof(LONGEST) * 2 + 1];
+ unsigned int val;
+ char membuf[sizeof(int) * 2 + 1];
char *p;
char *cmd;
int i;
+#if 0
+ /* Can't actually use long longs (nice idea, though). In fact, the
+ call to strtoul below will fail if it tries to convert a value
+ that's too big to fit in a long. */
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
{
len = 8;
cmd = current_monitor->getmem.cmdll;
}
- else if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
+ else
+#endif
+ if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
{
len = 4;
cmd = current_monitor->getmem.cmdl;
cmd = current_monitor->getmem.cmdb;
}
-/* Send the examine command. */
+ /* Send the examine command. */
monitor_printf (cmd, memaddr);
-/* If RESP_DELIM is specified, we search for that as a leading delimiter for
- the register value. Otherwise, we just start searching from the start of
- the buf. */
+ /* If RESP_DELIM is specified, we search for that as a leading
+ delimiter for the memory value. Otherwise, we just start
+ searching from the start of the buf. */
if (current_monitor->getmem.resp_delim)
- monitor_expect (current_monitor->getmem.resp_delim, NULL, 0);
+ monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
-/* Now, read the appropriate number of hex digits for this loc, skipping
- spaces. */
+ /* Now, read the appropriate number of hex digits for this loc,
+ skipping spaces. */
+ /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
+ if (current_monitor->flags & MO_HEX_PREFIX)
+ {
+ int c;
+
+ c = readchar (timeout);
+ while (c == ' ')
+ c = readchar (timeout);
+ if ((c == '0') && ((c = readchar (timeout)) == 'x'))
+ ;
+ else
+ error ("monitor_read_memory_single (0x%x): bad response from monitor: %.*s%c.",
+ memaddr, i, membuf, c);
+ }
for (i = 0; i < len * 2; i++)
{
int c;
char *myaddr;
int len;
{
- unsigned LONGEST val;
+ unsigned int val;
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
char buf[512];
char *p, *p1;
len = min (len, 16);
-/* See if xfer would cross a 16 byte boundary. If so, clip it. */
+ /* See if xfer would cross a 16 byte boundary. If so, clip it. */
if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
len = ((memaddr + len) & ~0xf) - memaddr;
- /* send the memory examine command */
+ /* send the memory examine command */
if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len - 1);
else
monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
-/* If TERM is present, we wait for that to show up. Also, (if TERM is
- present), we will send TERM_CMD if that is present. In any case, we collect
- all of the output into buf, and then wait for the normal prompt. */
+ /* If TERM is present, we wait for that to show up. Also, (if TERM
+ is present), we will send TERM_CMD if that is present. In any
+ case, we collect all of the output into buf, and then wait for
+ the normal prompt. */
if (current_monitor->getmem.term)
{
p = buf;
- /* If RESP_DELIM is specified, we search for that as a leading delimiter for
- the values. Otherwise, we just start searching from the start of the buf.
- */
+ /* If RESP_DELIM is specified, we search for that as a leading
+ delimiter for the values. Otherwise, we just start searching
+ from the start of the buf. */
if (current_monitor->getmem.resp_delim)
{
+ int retval, tmp;
+ struct re_registers resp_strings;
+
+ tmp = strlen (p);
+ retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
+ &resp_strings);
+
+ if (retval < 0)
+ error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
+ memaddr, resp_len, buf);
+
+ p += resp_strings.end[0];
+#if 0
p = strstr (p, current_monitor->getmem.resp_delim);
if (!p)
error ("monitor_read_memory (0x%x): bad response from monitor: %.*s.",
memaddr, resp_len, buf);
p += strlen (current_monitor->getmem.resp_delim);
+#endif
}
for (i = len; i > 0; i--)
int write;
struct target_ops *target; /* ignored */
{
- if (write)
- return monitor_write_memory (memaddr, myaddr, len);
- else
- return monitor_read_memory (memaddr, myaddr, len);
+ return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
}
static void
if (args && (*args != '\000'))
error ("Args are not supported by the monitor.");
+ first_time = 1;
clear_proceed_status ();
proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
}
char *shadow;
{
int i;
+ /* This is only used to compute the size of a breakpoint. */
+#ifdef BREAKPOINT
static unsigned char break_insn[] = BREAKPOINT;
+#else
+ /* In the bi-endian case we assume breakpoints are the same size. */
+ static unsigned char break_insn[] = BIG_BREAKPOINT;
+#endif
for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
{
{
breakaddr[i] = addr;
monitor_read_memory (addr, shadow, sizeof (break_insn));
- monitor_printf (SET_BREAK_CMD, addr);
+ monitor_printf (current_monitor->set_break, addr);
monitor_expect_prompt (NULL, 0);
return 0;
}
breakaddr[i] = 0;
/* some monitors remove breakpoints based on the address */
if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
- monitor_printf (CLR_BREAK_CMD, addr);
+ monitor_printf (current_monitor->clr_break, addr);
else
- monitor_printf (CLR_BREAK_CMD, i);
+ monitor_printf (current_monitor->clr_break, i);
monitor_expect_prompt (NULL, 0);
return 0;
}
return 1;
}
+/* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
+ an S-record. Return non-zero if the ACK is received properly. */
+
+static int
+monitor_wait_srec_ack ()
+{
+ /* FIXME: eventually we'll want to be able to handle acknowledgements
+ of something other than a '+' character. Right now this is only
+ going to work for EST visionICE. */
+ return readchar (timeout) == '+';
+}
+
/* monitor_load -- download a file. */
static void
char *file;
int from_tty;
{
+ dcache_flush (remote_dcache);
+
if (current_monitor->load_routine)
current_monitor->load_routine (monitor_desc, file, hashmark);
else
- monitor_load_srec (file);
+ { /* The default is ascii S-records */
+ monitor_printf (current_monitor->load);
+ if (current_monitor->loadresp)
+ monitor_expect (current_monitor->loadresp, NULL, 0);
+
+/* FIXME Should add arg here for load_offset (already done for generic_load) */
+ load_srec (monitor_desc, file, 32, SREC_ALL, hashmark,
+ current_monitor->flags & MO_SREC_ACK ?
+ monitor_wait_srec_ack : NULL);
+
+ monitor_expect_prompt (NULL, 0);
+ }
/* Finally, make the PC point at the start address */
- write_pc (bfd_get_start_address (exec_bfd));
+ if (exec_bfd)
+ write_pc (bfd_get_start_address (exec_bfd));
inferior_pid = 0; /* No process now */
static void
monitor_stop ()
{
+ if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
+ SERIAL_SEND_BREAK (monitor_desc);
if (current_monitor->stop)
monitor_printf_noecho (current_monitor->stop);
}
if (monitor_desc == NULL)
error ("monitor target not open.");
- p = PROMPT;
+ p = current_monitor->prompt;
/* Send the command. Note that if no args were supplied, then we're
just sending the monitor a newline, which is sometimes useful. */
fputs_unfiltered (buf, gdb_stdout); /* Output the response */
}
-/* Download a binary file by converting it to S records. */
-
-static void
-monitor_load_srec (args)
- char *args;
-{
- bfd *abfd;
- asection *s;
- char *buffer, srec[1024];
- int i;
- int srec_frame = 32;
- int reclen;
-
- buffer = alloca (srec_frame * 2 + 256);
-
- 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;
- }
-
- monitor_printf (LOAD_CMD); /* tell the monitor to load */
- if (current_monitor->loadresp)
- monitor_expect (current_monitor->loadresp, NULL, 0);
-
- for (s = abfd->sections; s; s = s->next)
- if (s->flags & SEC_LOAD)
- {
- printf_filtered ("%s\t: 0x%4x .. 0x%4x ", s->name, s->vma,
- s->vma + s->_raw_size);
- gdb_flush (gdb_stdout);
-
- for (i = 0; i < s->_raw_size; i += srec_frame)
- {
- int numbytes;
-
- numbytes = min (srec_frame, s->_raw_size - i);
-
- bfd_get_section_contents (abfd, s, buffer, i, numbytes);
-
- reclen = monitor_make_srec (srec, 3, s->vma + i, buffer, numbytes);
-
- monitor_printf_noecho ("%.*s\r", reclen, srec);
-
- if (hashmark)
- {
- putchar_unfiltered ('#');
- gdb_flush (gdb_stdout);
- }
- } /* Per-packet (or S-record) loop */
-
- putchar_unfiltered ('\n');
- } /* Loadable sections */
-
- if (hashmark)
- putchar_unfiltered ('\n');
-
- /* Write a type 7 terminator record. no data for a type 7, and there
- is no data, so len is 0. */
-
- reclen = monitor_make_srec (srec, 7, abfd->start_address, NULL, 0);
-
- monitor_printf_noecho ("%.*s\r", reclen, srec);
-
- monitor_printf_noecho ("\r\r"); /* Some monitors need these to wake up */
-
- monitor_expect_prompt (NULL, 0);
-
- SERIAL_FLUSH_INPUT (monitor_desc);
-}
-
-/*
- * monitor_make_srec -- make an srecord. This writes each line, one at a
- * time, each with it's own header and trailer line.
- * An srecord looks like this:
- *
- * byte count-+ address
- * start ---+ | | data +- checksum
- * | | | |
- * S01000006F6B692D746573742E73726563E4
- * S315000448600000000000000000FC00005900000000E9
- * S31A0004000023C1400037DE00F023604000377B009020825000348D
- * S30B0004485A0000000000004E
- * S70500040000F6
- *
- * S<type><length><address><data><checksum>
- *
- * Where
- * - length
- * is the number of bytes following upto the checksum. Note that
- * this is not the number of chars following, since it takes two
- * chars to represent a byte.
- * - type
- * is one of:
- * 0) header record
- * 1) two byte address data record
- * 2) three byte address data record
- * 3) four byte address data record
- * 7) four byte address termination record
- * 8) three byte address termination record
- * 9) two byte address termination record
- *
- * - address
- * is the start address of the data following, or in the case of
- * a termination record, the start address of the image
- * - data
- * is the data.
- * - checksum
- * is the sum of all the raw byte data in the record, from the length
- * upwards, modulo 256 and subtracted from 255.
- *
- * This routine returns the length of the S-record.
- *
- */
-
-static int
-monitor_make_srec (buffer, type, memaddr, myaddr, len)
- char *buffer;
- int type;
- CORE_ADDR memaddr;
- unsigned char *myaddr;
- int len;
-{
- unsigned char checksum;
- int i;
- char *buf;
- static char hextab[] = "0123456789ABCDEF";
-
- buf = buffer;
-
- checksum = 0;
-
- /* Create the header for the srec. 4 is the number of bytes in the address,
- and 1 is the number of bytes in the count. */
-
- sprintf (buf, "S%d%02X%08X", type, len + 4 + 1, memaddr);
- buf += 12;
-
-/* Note that the checksum is calculated on the raw data, not the hexified
- data. It includes the length, address and the data portions of the
- packet. */
-
- checksum += (len + 4 + 1 /* Packet length */
- + (memaddr & 0xff) /* Address... */
- + ((memaddr >> 8) & 0xff)
- + ((memaddr >> 16) & 0xff)
- + ((memaddr >> 24) & 0xff));
-
- /* build the srecord */
- for (i = 0; i < len; i++)
- {
- *buf++ = hextab [myaddr[i] >> 4];
- *buf++ = hextab [myaddr[i] & 0xf];
- checksum += myaddr[i];
- }
-
- checksum = ~checksum;
-
- *buf++ = hextab[checksum >> 4];
- *buf++ = hextab[checksum & 0xf];
-
- return buf - buffer;
-}
-
/* Convert hex digit A to a number. */
static int
monitor_mourn_inferior, /* to_mourn_inferior */
0, /* to_can_run */
0, /* to_notice_signals */
+ 0, /* to_thread_alive */
monitor_stop, /* to_stop */
process_stratum, /* to_stratum */
0, /* to_next */
projects / deliverable / binutils-gdb.git / blobdiff