/* Remote debugging interface for boot monitors, for GDB.
|
/* Remote debugging interface for boot monitors, for GDB.
|
Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
|
Copyright 1990-1993, 1995-1997, 1999-2000 Free Software Foundation, Inc.
|
Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
|
Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
|
Resurrected from the ashes by Stu Grossman.
|
Resurrected from the ashes by Stu Grossman.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 2 of the License, or
|
the Free Software Foundation; either version 2 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program; if not, write to the Free Software
|
along with this program; if not, write to the Free Software
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Foundation, Inc., 59 Temple Place - Suite 330,
|
Boston, MA 02111-1307, USA. */
|
Boston, MA 02111-1307, USA. */
|
|
|
/* This file was derived from various remote-* modules. It is a collection
|
/* 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
|
of generic support functions so GDB can talk directly to a ROM based
|
monitor. This saves use from having to hack an exception based handler
|
monitor. This saves use from having to hack an exception based handler
|
into existance, and makes for quick porting.
|
into existance, and makes for quick porting.
|
|
|
This module talks to a debug monitor called 'MONITOR', which
|
This module talks to a debug monitor called 'MONITOR', which
|
We communicate with MONITOR via either a direct serial line, or a TCP
|
We communicate with MONITOR via either a direct serial line, or a TCP
|
(or possibly TELNET) stream to a terminal multiplexor,
|
(or possibly TELNET) stream to a terminal multiplexor,
|
which in turn talks to the target board. */
|
which in turn talks to the target board. */
|
|
|
/* FIXME 32x64: This code assumes that registers and addresses are at
|
/* 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
|
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
|
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
|
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,
|
any actual 64-bit targets with ROM monitors that use this code,
|
it's not an issue right now. -sts 4/18/96 */
|
it's not an issue right now. -sts 4/18/96 */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "gdbcore.h"
|
#include "gdbcore.h"
|
#include "target.h"
|
#include "target.h"
|
#include "gdb_wait.h"
|
#include "gdb_wait.h"
|
#include <signal.h>
|
#include <signal.h>
|
#include <ctype.h>
|
#include <ctype.h>
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include <sys/types.h>
|
#include <sys/types.h>
|
#include "command.h"
|
#include "command.h"
|
#include "serial.h"
|
#include "serial.h"
|
#include "monitor.h"
|
#include "monitor.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "inferior.h"
|
#include "inferior.h"
|
#include "gdb_regex.h"
|
#include "gdb_regex.h"
|
#include "dcache.h"
|
#include "dcache.h"
|
#include "srec.h"
|
#include "srec.h"
|
|
|
static char *dev_name;
|
static char *dev_name;
|
static struct target_ops *targ_ops;
|
static struct target_ops *targ_ops;
|
|
|
static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
|
static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
|
|
|
static int readchar PARAMS ((int timeout));
|
static int readchar PARAMS ((int timeout));
|
|
|
static void monitor_fetch_register PARAMS ((int regno));
|
static void monitor_fetch_register PARAMS ((int regno));
|
static void monitor_store_register PARAMS ((int regno));
|
static void monitor_store_register PARAMS ((int regno));
|
|
|
static void monitor_printable_string (char *newstr, char *oldstr, int len);
|
static void monitor_printable_string (char *newstr, char *oldstr, int len);
|
static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
|
static void monitor_error (char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char);
|
static void monitor_detach PARAMS ((char *args, int from_tty));
|
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_resume PARAMS ((int pid, int step, enum target_signal sig));
|
static void monitor_interrupt PARAMS ((int signo));
|
static void monitor_interrupt PARAMS ((int signo));
|
static void monitor_interrupt_twice PARAMS ((int signo));
|
static void monitor_interrupt_twice PARAMS ((int signo));
|
static void monitor_interrupt_query PARAMS ((void));
|
static void monitor_interrupt_query PARAMS ((void));
|
static void monitor_wait_cleanup PARAMS ((void *old_timeout));
|
static void monitor_wait_cleanup PARAMS ((void *old_timeout));
|
|
|
static int monitor_wait PARAMS ((int pid, struct target_waitstatus * status));
|
static int monitor_wait PARAMS ((int pid, struct target_waitstatus * status));
|
static void monitor_fetch_registers PARAMS ((int regno));
|
static void monitor_fetch_registers PARAMS ((int regno));
|
static void monitor_store_registers PARAMS ((int regno));
|
static void monitor_store_registers PARAMS ((int regno));
|
static void monitor_prepare_to_store PARAMS ((void));
|
static void monitor_prepare_to_store PARAMS ((void));
|
static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops * target));
|
static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops * target));
|
static void monitor_files_info PARAMS ((struct target_ops * ops));
|
static void monitor_files_info PARAMS ((struct target_ops * ops));
|
static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
|
static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
|
static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
|
static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
|
static void monitor_kill PARAMS ((void));
|
static void monitor_kill PARAMS ((void));
|
static void monitor_load PARAMS ((char *file, int from_tty));
|
static void monitor_load PARAMS ((char *file, int from_tty));
|
static void monitor_mourn_inferior PARAMS ((void));
|
static void monitor_mourn_inferior PARAMS ((void));
|
static void monitor_stop PARAMS ((void));
|
static void monitor_stop PARAMS ((void));
|
|
|
static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
|
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_write_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
|
static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
|
static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
|
char *myaddr, int len));
|
char *myaddr, int len));
|
static int monitor_write_memory_block PARAMS ((
|
static int monitor_write_memory_block PARAMS ((
|
CORE_ADDR memaddr,
|
CORE_ADDR memaddr,
|
char *myaddr,
|
char *myaddr,
|
int len));
|
int len));
|
static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer * pat,
|
static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer * pat,
|
char *buf, int buflen));
|
char *buf, int buflen));
|
static void monitor_dump_regs PARAMS ((void));
|
static void monitor_dump_regs PARAMS ((void));
|
#if 0
|
#if 0
|
static int from_hex PARAMS ((int a));
|
static int from_hex PARAMS ((int a));
|
static unsigned long get_hex_word PARAMS ((void));
|
static unsigned long get_hex_word PARAMS ((void));
|
#endif
|
#endif
|
static void parse_register_dump PARAMS ((char *, int));
|
static void parse_register_dump PARAMS ((char *, int));
|
|
|
static struct monitor_ops *current_monitor;
|
static struct monitor_ops *current_monitor;
|
|
|
static int hashmark; /* flag set by "set hash" */
|
static int hashmark; /* flag set by "set hash" */
|
|
|
static int timeout = 30;
|
static int timeout = 30;
|
|
|
static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
|
static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
|
|
|
static void (*ofunc) (); /* Old SIGINT signal handler */
|
static void (*ofunc) (); /* Old SIGINT signal handler */
|
|
|
static CORE_ADDR *breakaddr;
|
static CORE_ADDR *breakaddr;
|
|
|
/* Descriptor for I/O to remote machine. Initialize it to NULL so
|
/* Descriptor for I/O to remote machine. Initialize it to NULL so
|
that monitor_open knows that we don't have a file open when the
|
that monitor_open knows that we don't have a file open when the
|
program starts. */
|
program starts. */
|
|
|
static serial_t monitor_desc = NULL;
|
static serial_t monitor_desc = NULL;
|
|
|
/* Pointer to regexp pattern matching data */
|
/* Pointer to regexp pattern matching data */
|
|
|
static struct re_pattern_buffer register_pattern;
|
static struct re_pattern_buffer register_pattern;
|
static char register_fastmap[256];
|
static char register_fastmap[256];
|
|
|
static struct re_pattern_buffer getmem_resp_delim_pattern;
|
static struct re_pattern_buffer getmem_resp_delim_pattern;
|
static char getmem_resp_delim_fastmap[256];
|
static char getmem_resp_delim_fastmap[256];
|
|
|
static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
|
static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
|
monitor_wait wakes up. */
|
monitor_wait wakes up. */
|
|
|
static DCACHE *remote_dcache;
|
static DCACHE *remote_dcache;
|
static int first_time = 0; /* is this the first time we're executing after
|
static int first_time = 0; /* is this the first time we're executing after
|
gaving created the child proccess? */
|
gaving created the child proccess? */
|
|
|
#define TARGET_BUF_SIZE 2048
|
#define TARGET_BUF_SIZE 2048
|
|
|
/* Monitor specific debugging information. Typically only useful to
|
/* Monitor specific debugging information. Typically only useful to
|
the developer of a new monitor interface. */
|
the developer of a new monitor interface. */
|
|
|
static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
|
static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
|
|
|
static int monitor_debug_p = 0;
|
static int monitor_debug_p = 0;
|
|
|
/* NOTE: This file alternates between monitor_debug_p and remote_debug
|
/* NOTE: This file alternates between monitor_debug_p and remote_debug
|
when determining if debug information is printed. Perhaphs this
|
when determining if debug information is printed. Perhaphs this
|
could be simplified. */
|
could be simplified. */
|
|
|
static void
|
static void
|
monitor_debug (const char *fmt, ...)
|
monitor_debug (const char *fmt, ...)
|
{
|
{
|
if (monitor_debug_p)
|
if (monitor_debug_p)
|
{
|
{
|
va_list args;
|
va_list args;
|
va_start (args, fmt);
|
va_start (args, fmt);
|
vfprintf_filtered (gdb_stdlog, fmt, args);
|
vfprintf_filtered (gdb_stdlog, fmt, args);
|
va_end (args);
|
va_end (args);
|
}
|
}
|
}
|
}
|
|
|
|
|
/* Convert a string into a printable representation, Return # byte in
|
/* Convert a string into a printable representation, Return # byte in
|
the new string. When LEN is >0 it specifies the size of the
|
the new string. When LEN is >0 it specifies the size of the
|
string. Otherwize strlen(oldstr) is used. */
|
string. Otherwize strlen(oldstr) is used. */
|
|
|
static void
|
static void
|
monitor_printable_string (char *newstr, char *oldstr, int len)
|
monitor_printable_string (char *newstr, char *oldstr, int len)
|
{
|
{
|
int ch;
|
int ch;
|
int i;
|
int i;
|
|
|
if (len <= 0)
|
if (len <= 0)
|
len = strlen (oldstr);
|
len = strlen (oldstr);
|
|
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
{
|
{
|
ch = oldstr[i];
|
ch = oldstr[i];
|
switch (ch)
|
switch (ch)
|
{
|
{
|
default:
|
default:
|
if (isprint (ch))
|
if (isprint (ch))
|
*newstr++ = ch;
|
*newstr++ = ch;
|
|
|
else
|
else
|
{
|
{
|
sprintf (newstr, "\\x%02x", ch & 0xff);
|
sprintf (newstr, "\\x%02x", ch & 0xff);
|
newstr += 4;
|
newstr += 4;
|
}
|
}
|
break;
|
break;
|
|
|
case '\\':
|
case '\\':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
break;
|
break;
|
case '\b':
|
case '\b':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = 'b';
|
*newstr++ = 'b';
|
break;
|
break;
|
case '\f':
|
case '\f':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = 't';
|
*newstr++ = 't';
|
break;
|
break;
|
case '\n':
|
case '\n':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = 'n';
|
*newstr++ = 'n';
|
break;
|
break;
|
case '\r':
|
case '\r':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = 'r';
|
*newstr++ = 'r';
|
break;
|
break;
|
case '\t':
|
case '\t':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = 't';
|
*newstr++ = 't';
|
break;
|
break;
|
case '\v':
|
case '\v':
|
*newstr++ = '\\';
|
*newstr++ = '\\';
|
*newstr++ = 'v';
|
*newstr++ = 'v';
|
break;
|
break;
|
}
|
}
|
}
|
}
|
|
|
*newstr++ = '\0';
|
*newstr++ = '\0';
|
}
|
}
|
|
|
/* Print monitor errors with a string, converting the string to printable
|
/* Print monitor errors with a string, converting the string to printable
|
representation. */
|
representation. */
|
|
|
static void
|
static void
|
monitor_error (char *function, char *message,
|
monitor_error (char *function, char *message,
|
CORE_ADDR memaddr, int len, char *string, int final_char)
|
CORE_ADDR memaddr, int len, char *string, int final_char)
|
{
|
{
|
int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
|
int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
|
char *safe_string = alloca ((real_len * 4) + 1);
|
char *safe_string = alloca ((real_len * 4) + 1);
|
monitor_printable_string (safe_string, string, real_len);
|
monitor_printable_string (safe_string, string, real_len);
|
|
|
if (final_char)
|
if (final_char)
|
error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
|
error ("%s (0x%s): %s: %s%c", function, paddr_nz (memaddr), message, safe_string, final_char);
|
else
|
else
|
error ("%s (0x%s): %s: %s", function, paddr_nz (memaddr), message, safe_string);
|
error ("%s (0x%s): %s: %s", function, paddr_nz (memaddr), message, safe_string);
|
}
|
}
|
|
|
/* Convert hex digit A to a number. */
|
/* Convert hex digit A to a number. */
|
|
|
static int
|
static int
|
fromhex (a)
|
fromhex (a)
|
int a;
|
int a;
|
{
|
{
|
if (a >= '0' && a <= '9')
|
if (a >= '0' && a <= '9')
|
return a - '0';
|
return a - '0';
|
else if (a >= 'a' && a <= 'f')
|
else if (a >= 'a' && a <= 'f')
|
return a - 'a' + 10;
|
return a - 'a' + 10;
|
else if (a >= 'A' && a <= 'F')
|
else if (a >= 'A' && a <= 'F')
|
return a - 'A' + 10;
|
return a - 'A' + 10;
|
else
|
else
|
error ("Invalid hex digit %d", a);
|
error ("Invalid hex digit %d", a);
|
}
|
}
|
|
|
/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
|
/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
|
|
|
This function exists to get around the problem that many host platforms
|
This function exists to get around the problem that many host platforms
|
don't have a printf that can print 64-bit addresses. The %A format
|
don't have a printf that can print 64-bit addresses. The %A format
|
specification is recognized as a special case, and causes the argument
|
specification is recognized as a special case, and causes the argument
|
to be printed as a 64-bit hexadecimal address.
|
to be printed as a 64-bit hexadecimal address.
|
|
|
Only format specifiers of the form "[0-9]*[a-z]" are recognized.
|
Only format specifiers of the form "[0-9]*[a-z]" are recognized.
|
If it is a '%s' format, the argument is a string; otherwise the
|
If it is a '%s' format, the argument is a string; otherwise the
|
argument is assumed to be a long integer.
|
argument is assumed to be a long integer.
|
|
|
%% is also turned into a single %.
|
%% is also turned into a single %.
|
*/
|
*/
|
|
|
static void
|
static void
|
monitor_vsprintf (sndbuf, pattern, args)
|
monitor_vsprintf (sndbuf, pattern, args)
|
char *sndbuf;
|
char *sndbuf;
|
char *pattern;
|
char *pattern;
|
va_list args;
|
va_list args;
|
{
|
{
|
char format[10];
|
char format[10];
|
char fmt;
|
char fmt;
|
char *p;
|
char *p;
|
int i;
|
int i;
|
long arg_int;
|
long arg_int;
|
CORE_ADDR arg_addr;
|
CORE_ADDR arg_addr;
|
char *arg_string;
|
char *arg_string;
|
|
|
for (p = pattern; *p; p++)
|
for (p = pattern; *p; p++)
|
{
|
{
|
if (*p == '%')
|
if (*p == '%')
|
{
|
{
|
/* Copy the format specifier to a separate buffer. */
|
/* Copy the format specifier to a separate buffer. */
|
format[0] = *p++;
|
format[0] = *p++;
|
for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
|
for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
|
i++, p++)
|
i++, p++)
|
format[i] = *p;
|
format[i] = *p;
|
format[i] = fmt = *p;
|
format[i] = fmt = *p;
|
format[i + 1] = '\0';
|
format[i + 1] = '\0';
|
|
|
/* Fetch the next argument and print it. */
|
/* Fetch the next argument and print it. */
|
switch (fmt)
|
switch (fmt)
|
{
|
{
|
case '%':
|
case '%':
|
strcpy (sndbuf, "%");
|
strcpy (sndbuf, "%");
|
break;
|
break;
|
case 'A':
|
case 'A':
|
arg_addr = va_arg (args, CORE_ADDR);
|
arg_addr = va_arg (args, CORE_ADDR);
|
strcpy (sndbuf, paddr_nz (arg_addr));
|
strcpy (sndbuf, paddr_nz (arg_addr));
|
break;
|
break;
|
case 's':
|
case 's':
|
arg_string = va_arg (args, char *);
|
arg_string = va_arg (args, char *);
|
sprintf (sndbuf, format, arg_string);
|
sprintf (sndbuf, format, arg_string);
|
break;
|
break;
|
default:
|
default:
|
arg_int = va_arg (args, long);
|
arg_int = va_arg (args, long);
|
sprintf (sndbuf, format, arg_int);
|
sprintf (sndbuf, format, arg_int);
|
break;
|
break;
|
}
|
}
|
sndbuf += strlen (sndbuf);
|
sndbuf += strlen (sndbuf);
|
}
|
}
|
else
|
else
|
*sndbuf++ = *p;
|
*sndbuf++ = *p;
|
}
|
}
|
*sndbuf = '\0';
|
*sndbuf = '\0';
|
}
|
}
|
|
|
|
|
/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
|
/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
|
Works just like printf. */
|
Works just like printf. */
|
|
|
void
|
void
|
monitor_printf_noecho (char *pattern,...)
|
monitor_printf_noecho (char *pattern,...)
|
{
|
{
|
va_list args;
|
va_list args;
|
char sndbuf[2000];
|
char sndbuf[2000];
|
int len;
|
int len;
|
|
|
va_start (args, pattern);
|
va_start (args, pattern);
|
|
|
monitor_vsprintf (sndbuf, pattern, args);
|
monitor_vsprintf (sndbuf, pattern, args);
|
|
|
len = strlen (sndbuf);
|
len = strlen (sndbuf);
|
if (len + 1 > sizeof sndbuf)
|
if (len + 1 > sizeof sndbuf)
|
abort ();
|
abort ();
|
|
|
if (monitor_debug_p)
|
if (monitor_debug_p)
|
{
|
{
|
char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
|
char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
|
monitor_printable_string (safe_string, sndbuf, 0);
|
monitor_printable_string (safe_string, sndbuf, 0);
|
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
|
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
|
}
|
}
|
|
|
monitor_write (sndbuf, len);
|
monitor_write (sndbuf, len);
|
}
|
}
|
|
|
/* monitor_printf -- Send data to monitor and check the echo. Works just like
|
/* monitor_printf -- Send data to monitor and check the echo. Works just like
|
printf. */
|
printf. */
|
|
|
void
|
void
|
monitor_printf (char *pattern,...)
|
monitor_printf (char *pattern,...)
|
{
|
{
|
va_list args;
|
va_list args;
|
char sndbuf[2000];
|
char sndbuf[2000];
|
int len;
|
int len;
|
|
|
va_start (args, pattern);
|
va_start (args, pattern);
|
|
|
monitor_vsprintf (sndbuf, pattern, args);
|
monitor_vsprintf (sndbuf, pattern, args);
|
|
|
len = strlen (sndbuf);
|
len = strlen (sndbuf);
|
if (len + 1 > sizeof sndbuf)
|
if (len + 1 > sizeof sndbuf)
|
abort ();
|
abort ();
|
|
|
if (monitor_debug_p)
|
if (monitor_debug_p)
|
{
|
{
|
char *safe_string = (char *) alloca ((len * 4) + 1);
|
char *safe_string = (char *) alloca ((len * 4) + 1);
|
monitor_printable_string (safe_string, sndbuf, 0);
|
monitor_printable_string (safe_string, sndbuf, 0);
|
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
|
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
|
}
|
}
|
|
|
monitor_write (sndbuf, len);
|
monitor_write (sndbuf, len);
|
|
|
/* We used to expect that the next immediate output was the characters we
|
/* We used to expect that the next immediate output was the characters we
|
just output, but sometimes some extra junk appeared before the characters
|
just output, but sometimes some extra junk appeared before the characters
|
we expected, like an extra prompt, or a portmaster sending telnet negotiations.
|
we expected, like an extra prompt, or a portmaster sending telnet negotiations.
|
So, just start searching for what we sent, and skip anything unknown. */
|
So, just start searching for what we sent, and skip anything unknown. */
|
monitor_debug ("ExpectEcho\n");
|
monitor_debug ("ExpectEcho\n");
|
monitor_expect (sndbuf, (char *) 0, 0);
|
monitor_expect (sndbuf, (char *) 0, 0);
|
}
|
}
|
|
|
|
|
/* Write characters to the remote system. */
|
/* Write characters to the remote system. */
|
|
|
void
|
void
|
monitor_write (buf, buflen)
|
monitor_write (buf, buflen)
|
char *buf;
|
char *buf;
|
int buflen;
|
int buflen;
|
{
|
{
|
if (SERIAL_WRITE (monitor_desc, buf, buflen))
|
if (SERIAL_WRITE (monitor_desc, buf, buflen))
|
fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
|
fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
|
safe_strerror (errno));
|
safe_strerror (errno));
|
}
|
}
|
|
|
|
|
/* Read a binary character from the remote system, doing all the fancy
|
/* Read a binary character from the remote system, doing all the fancy
|
timeout stuff, but without interpreting the character in any way,
|
timeout stuff, but without interpreting the character in any way,
|
and without printing remote debug information. */
|
and without printing remote debug information. */
|
|
|
int
|
int
|
monitor_readchar ()
|
monitor_readchar ()
|
{
|
{
|
int c;
|
int c;
|
int looping;
|
int looping;
|
|
|
do
|
do
|
{
|
{
|
looping = 0;
|
looping = 0;
|
c = SERIAL_READCHAR (monitor_desc, timeout);
|
c = SERIAL_READCHAR (monitor_desc, timeout);
|
|
|
if (c >= 0)
|
if (c >= 0)
|
c &= 0xff; /* don't lose bit 7 */
|
c &= 0xff; /* don't lose bit 7 */
|
}
|
}
|
while (looping);
|
while (looping);
|
|
|
if (c >= 0)
|
if (c >= 0)
|
return c;
|
return c;
|
|
|
if (c == SERIAL_TIMEOUT)
|
if (c == SERIAL_TIMEOUT)
|
error ("Timeout reading from remote system.");
|
error ("Timeout reading from remote system.");
|
|
|
perror_with_name ("remote-monitor");
|
perror_with_name ("remote-monitor");
|
}
|
}
|
|
|
|
|
/* Read a character from the remote system, doing all the fancy
|
/* Read a character from the remote system, doing all the fancy
|
timeout stuff. */
|
timeout stuff. */
|
|
|
static int
|
static int
|
readchar (timeout)
|
readchar (timeout)
|
int timeout;
|
int timeout;
|
{
|
{
|
int c;
|
int c;
|
static enum
|
static enum
|
{
|
{
|
last_random, last_nl, last_cr, last_crnl
|
last_random, last_nl, last_cr, last_crnl
|
}
|
}
|
state = last_random;
|
state = last_random;
|
int looping;
|
int looping;
|
|
|
do
|
do
|
{
|
{
|
looping = 0;
|
looping = 0;
|
c = SERIAL_READCHAR (monitor_desc, timeout);
|
c = SERIAL_READCHAR (monitor_desc, timeout);
|
|
|
if (c >= 0)
|
if (c >= 0)
|
{
|
{
|
c &= 0x7f;
|
c &= 0x7f;
|
/* This seems to interfere with proper function of the
|
/* This seems to interfere with proper function of the
|
input stream */
|
input stream */
|
if (monitor_debug_p || remote_debug)
|
if (monitor_debug_p || remote_debug)
|
{
|
{
|
char buf[2];
|
char buf[2];
|
buf[0] = c;
|
buf[0] = c;
|
buf[1] = '\0';
|
buf[1] = '\0';
|
puts_debug ("read -->", buf, "<--");
|
puts_debug ("read -->", buf, "<--");
|
}
|
}
|
|
|
}
|
}
|
|
|
/* Canonicialize \n\r combinations into one \r */
|
/* Canonicialize \n\r combinations into one \r */
|
if ((current_monitor->flags & MO_HANDLE_NL) != 0)
|
if ((current_monitor->flags & MO_HANDLE_NL) != 0)
|
{
|
{
|
if ((c == '\r' && state == last_nl)
|
if ((c == '\r' && state == last_nl)
|
|| (c == '\n' && state == last_cr))
|
|| (c == '\n' && state == last_cr))
|
{
|
{
|
state = last_crnl;
|
state = last_crnl;
|
looping = 1;
|
looping = 1;
|
}
|
}
|
else if (c == '\r')
|
else if (c == '\r')
|
state = last_cr;
|
state = last_cr;
|
else if (c != '\n')
|
else if (c != '\n')
|
state = last_random;
|
state = last_random;
|
else
|
else
|
{
|
{
|
state = last_nl;
|
state = last_nl;
|
c = '\r';
|
c = '\r';
|
}
|
}
|
}
|
}
|
}
|
}
|
while (looping);
|
while (looping);
|
|
|
if (c >= 0)
|
if (c >= 0)
|
return c;
|
return c;
|
|
|
if (c == SERIAL_TIMEOUT)
|
if (c == SERIAL_TIMEOUT)
|
#if 0
|
#if 0
|
/* I fail to see how detaching here can be useful */
|
/* I fail to see how detaching here can be useful */
|
if (in_monitor_wait) /* Watchdog went off */
|
if (in_monitor_wait) /* Watchdog went off */
|
{
|
{
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
error ("GDB serial timeout has expired. Target detached.\n");
|
error ("GDB serial timeout has expired. Target detached.\n");
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
error ("Timeout reading from remote system.");
|
error ("Timeout reading from remote system.");
|
|
|
perror_with_name ("remote-monitor");
|
perror_with_name ("remote-monitor");
|
}
|
}
|
|
|
/* Scan input from the remote system, until STRING is found. If BUF is non-
|
/* Scan input from the remote system, until STRING is found. If BUF is non-
|
zero, then collect input until we have collected either STRING or BUFLEN-1
|
zero, then collect input until we have collected either STRING or BUFLEN-1
|
chars. In either case we terminate BUF with a 0. If input overflows BUF
|
chars. In either case we terminate BUF with a 0. If input overflows BUF
|
because STRING can't be found, return -1, else return number of chars in BUF
|
because STRING can't be found, return -1, else return number of chars in BUF
|
(minus the terminating NUL). Note that in the non-overflow case, STRING
|
(minus the terminating NUL). Note that in the non-overflow case, STRING
|
will be at the end of BUF. */
|
will be at the end of BUF. */
|
|
|
int
|
int
|
monitor_expect (string, buf, buflen)
|
monitor_expect (string, buf, buflen)
|
char *string;
|
char *string;
|
char *buf;
|
char *buf;
|
int buflen;
|
int buflen;
|
{
|
{
|
char *p = string;
|
char *p = string;
|
int obuflen = buflen;
|
int obuflen = buflen;
|
int c;
|
int c;
|
extern struct target_ops *targ_ops;
|
extern struct target_ops *targ_ops;
|
|
|
if (monitor_debug_p)
|
if (monitor_debug_p)
|
{
|
{
|
char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
|
char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
|
monitor_printable_string (safe_string, string, 0);
|
monitor_printable_string (safe_string, string, 0);
|
fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
|
fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
|
}
|
}
|
|
|
immediate_quit = 1;
|
immediate_quit = 1;
|
while (1)
|
while (1)
|
{
|
{
|
if (buf)
|
if (buf)
|
{
|
{
|
if (buflen < 2)
|
if (buflen < 2)
|
{
|
{
|
*buf = '\000';
|
*buf = '\000';
|
immediate_quit = 0;
|
immediate_quit = 0;
|
return -1;
|
return -1;
|
}
|
}
|
|
|
c = readchar (timeout);
|
c = readchar (timeout);
|
if (c == '\000')
|
if (c == '\000')
|
continue;
|
continue;
|
*buf++ = c;
|
*buf++ = c;
|
buflen--;
|
buflen--;
|
}
|
}
|
else
|
else
|
c = readchar (timeout);
|
c = readchar (timeout);
|
|
|
/* Don't expect any ^C sent to be echoed */
|
/* Don't expect any ^C sent to be echoed */
|
|
|
if (*p == '\003' || c == *p)
|
if (*p == '\003' || c == *p)
|
{
|
{
|
p++;
|
p++;
|
if (*p == '\0')
|
if (*p == '\0')
|
{
|
{
|
immediate_quit = 0;
|
immediate_quit = 0;
|
|
|
if (buf)
|
if (buf)
|
{
|
{
|
*buf++ = '\000';
|
*buf++ = '\000';
|
return obuflen - buflen;
|
return obuflen - buflen;
|
}
|
}
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
else if ((c == '\021' || c == '\023') &&
|
else if ((c == '\021' || c == '\023') &&
|
(STREQ (targ_ops->to_shortname, "m32r")
|
(STREQ (targ_ops->to_shortname, "m32r")
|
|| STREQ (targ_ops->to_shortname, "mon2000")))
|
|| STREQ (targ_ops->to_shortname, "mon2000")))
|
{ /* m32r monitor emits random DC1/DC3 chars */
|
{ /* m32r monitor emits random DC1/DC3 chars */
|
continue;
|
continue;
|
}
|
}
|
else
|
else
|
{
|
{
|
/* We got a character that doesn't match the string. We need to
|
/* We got a character that doesn't match the string. We need to
|
back up p, but how far? If we're looking for "..howdy" and the
|
back up p, but how far? If we're looking for "..howdy" and the
|
monitor sends "...howdy"? There's certainly a match in there,
|
monitor sends "...howdy"? There's certainly a match in there,
|
but when we receive the third ".", we won't find it if we just
|
but when we receive the third ".", we won't find it if we just
|
restart the matching at the beginning of the string.
|
restart the matching at the beginning of the string.
|
|
|
This is a Boyer-Moore kind of situation. We want to reset P to
|
This is a Boyer-Moore kind of situation. We want to reset P to
|
the end of the longest prefix of STRING that is a suffix of
|
the end of the longest prefix of STRING that is a suffix of
|
what we've read so far. In the example above, that would be
|
what we've read so far. In the example above, that would be
|
".." --- the longest prefix of "..howdy" that is a suffix of
|
".." --- the longest prefix of "..howdy" that is a suffix of
|
"...". This longest prefix could be the empty string, if C
|
"...". This longest prefix could be the empty string, if C
|
is nowhere to be found in STRING.
|
is nowhere to be found in STRING.
|
|
|
If this longest prefix is not the empty string, it must contain
|
If this longest prefix is not the empty string, it must contain
|
C, so let's search from the end of STRING for instances of C,
|
C, so let's search from the end of STRING for instances of C,
|
and see if the portion of STRING before that is a suffix of
|
and see if the portion of STRING before that is a suffix of
|
what we read before C. Actually, we can search backwards from
|
what we read before C. Actually, we can search backwards from
|
p, since we know no prefix can be longer than that.
|
p, since we know no prefix can be longer than that.
|
|
|
Note that we can use STRING itself, along with C, as a record
|
Note that we can use STRING itself, along with C, as a record
|
of what we've received so far. :) */
|
of what we've received so far. :) */
|
int i;
|
int i;
|
|
|
for (i = (p - string) - 1; i >= 0; i--)
|
for (i = (p - string) - 1; i >= 0; i--)
|
if (string[i] == c)
|
if (string[i] == c)
|
{
|
{
|
/* Is this prefix a suffix of what we've read so far?
|
/* Is this prefix a suffix of what we've read so far?
|
In other words, does
|
In other words, does
|
string[0 .. i-1] == string[p - i, p - 1]? */
|
string[0 .. i-1] == string[p - i, p - 1]? */
|
if (! memcmp (string, p - i, i))
|
if (! memcmp (string, p - i, i))
|
{
|
{
|
p = string + i + 1;
|
p = string + i + 1;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
if (i < 0)
|
if (i < 0)
|
p = string;
|
p = string;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Search for a regexp. */
|
/* Search for a regexp. */
|
|
|
static int
|
static int
|
monitor_expect_regexp (pat, buf, buflen)
|
monitor_expect_regexp (pat, buf, buflen)
|
struct re_pattern_buffer *pat;
|
struct re_pattern_buffer *pat;
|
char *buf;
|
char *buf;
|
int buflen;
|
int buflen;
|
{
|
{
|
char *mybuf;
|
char *mybuf;
|
char *p;
|
char *p;
|
monitor_debug ("MON Expecting regexp\n");
|
monitor_debug ("MON Expecting regexp\n");
|
if (buf)
|
if (buf)
|
mybuf = buf;
|
mybuf = buf;
|
else
|
else
|
{
|
{
|
mybuf = alloca (TARGET_BUF_SIZE);
|
mybuf = alloca (TARGET_BUF_SIZE);
|
buflen = TARGET_BUF_SIZE;
|
buflen = TARGET_BUF_SIZE;
|
}
|
}
|
|
|
p = mybuf;
|
p = mybuf;
|
while (1)
|
while (1)
|
{
|
{
|
int retval;
|
int retval;
|
|
|
if (p - mybuf >= buflen)
|
if (p - mybuf >= buflen)
|
{ /* Buffer about to overflow */
|
{ /* Buffer about to overflow */
|
|
|
/* On overflow, we copy the upper half of the buffer to the lower half. Not
|
/* On overflow, we copy the upper half of the buffer to the lower half. Not
|
great, but it usually works... */
|
great, but it usually works... */
|
|
|
memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
|
memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
|
p = mybuf + buflen / 2;
|
p = mybuf + buflen / 2;
|
}
|
}
|
|
|
*p++ = readchar (timeout);
|
*p++ = readchar (timeout);
|
|
|
retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
|
retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
|
if (retval >= 0)
|
if (retval >= 0)
|
return 1;
|
return 1;
|
}
|
}
|
}
|
}
|
|
|
/* Keep discarding input until we see the MONITOR prompt.
|
/* Keep discarding input until we see the MONITOR prompt.
|
|
|
The convention for dealing with the prompt is that you
|
The convention for dealing with the prompt is that you
|
o give your command
|
o give your command
|
o *then* wait for the prompt.
|
o *then* wait for the prompt.
|
|
|
Thus the last thing that a procedure does with the serial line will
|
Thus the last thing that a procedure does with the serial line will
|
be an monitor_expect_prompt(). Exception: monitor_resume does not
|
be an monitor_expect_prompt(). Exception: monitor_resume does not
|
wait for the prompt, because the terminal is being handed over to
|
wait for the prompt, because the terminal is being handed over to
|
the inferior. However, the next thing which happens after that is
|
the inferior. However, the next thing which happens after that is
|
a monitor_wait which does wait for the prompt. Note that this
|
a monitor_wait which does wait for the prompt. Note that this
|
includes abnormal exit, e.g. error(). This is necessary to prevent
|
includes abnormal exit, e.g. error(). This is necessary to prevent
|
getting into states from which we can't recover. */
|
getting into states from which we can't recover. */
|
|
|
int
|
int
|
monitor_expect_prompt (buf, buflen)
|
monitor_expect_prompt (buf, buflen)
|
char *buf;
|
char *buf;
|
int buflen;
|
int buflen;
|
{
|
{
|
monitor_debug ("MON Expecting prompt\n");
|
monitor_debug ("MON Expecting prompt\n");
|
return monitor_expect (current_monitor->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
|
/* Get N 32-bit words from remote, each preceded by a space, and put
|
them in registers starting at REGNO. */
|
them in registers starting at REGNO. */
|
|
|
#if 0
|
#if 0
|
static unsigned long
|
static unsigned long
|
get_hex_word ()
|
get_hex_word ()
|
{
|
{
|
unsigned long val;
|
unsigned long val;
|
int i;
|
int i;
|
int ch;
|
int ch;
|
|
|
do
|
do
|
ch = readchar (timeout);
|
ch = readchar (timeout);
|
while (isspace (ch));
|
while (isspace (ch));
|
|
|
val = from_hex (ch);
|
val = from_hex (ch);
|
|
|
for (i = 7; i >= 1; i--)
|
for (i = 7; i >= 1; i--)
|
{
|
{
|
ch = readchar (timeout);
|
ch = readchar (timeout);
|
if (!isxdigit (ch))
|
if (!isxdigit (ch))
|
break;
|
break;
|
val = (val << 4) | from_hex (ch);
|
val = (val << 4) | from_hex (ch);
|
}
|
}
|
|
|
return val;
|
return val;
|
}
|
}
|
#endif
|
#endif
|
|
|
static void
|
static void
|
compile_pattern (pattern, compiled_pattern, fastmap)
|
compile_pattern (pattern, compiled_pattern, fastmap)
|
char *pattern;
|
char *pattern;
|
struct re_pattern_buffer *compiled_pattern;
|
struct re_pattern_buffer *compiled_pattern;
|
char *fastmap;
|
char *fastmap;
|
{
|
{
|
int tmp;
|
int tmp;
|
const char *val;
|
const char *val;
|
|
|
compiled_pattern->fastmap = fastmap;
|
compiled_pattern->fastmap = fastmap;
|
|
|
tmp = re_set_syntax (RE_SYNTAX_EMACS);
|
tmp = re_set_syntax (RE_SYNTAX_EMACS);
|
val = re_compile_pattern (pattern,
|
val = re_compile_pattern (pattern,
|
strlen (pattern),
|
strlen (pattern),
|
compiled_pattern);
|
compiled_pattern);
|
re_set_syntax (tmp);
|
re_set_syntax (tmp);
|
|
|
if (val)
|
if (val)
|
error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
|
error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
|
|
|
if (fastmap)
|
if (fastmap)
|
re_compile_fastmap (compiled_pattern);
|
re_compile_fastmap (compiled_pattern);
|
}
|
}
|
|
|
/* Open a connection to a remote debugger. NAME is the filename used
|
/* Open a connection to a remote debugger. NAME is the filename used
|
for communication. */
|
for communication. */
|
|
|
void
|
void
|
monitor_open (args, mon_ops, from_tty)
|
monitor_open (args, mon_ops, from_tty)
|
char *args;
|
char *args;
|
struct monitor_ops *mon_ops;
|
struct monitor_ops *mon_ops;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
char *name;
|
char *name;
|
char **p;
|
char **p;
|
|
|
if (mon_ops->magic != MONITOR_OPS_MAGIC)
|
if (mon_ops->magic != MONITOR_OPS_MAGIC)
|
error ("Magic number of monitor_ops struct wrong.");
|
error ("Magic number of monitor_ops struct wrong.");
|
|
|
targ_ops = mon_ops->target;
|
targ_ops = mon_ops->target;
|
name = targ_ops->to_shortname;
|
name = targ_ops->to_shortname;
|
|
|
if (!args)
|
if (!args)
|
error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
|
error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
|
`target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
|
`target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
|
|
|
target_preopen (from_tty);
|
target_preopen (from_tty);
|
|
|
/* Setup pattern for register dump */
|
/* Setup pattern for register dump */
|
|
|
if (mon_ops->register_pattern)
|
if (mon_ops->register_pattern)
|
compile_pattern (mon_ops->register_pattern, ®ister_pattern,
|
compile_pattern (mon_ops->register_pattern, ®ister_pattern,
|
register_fastmap);
|
register_fastmap);
|
|
|
if (mon_ops->getmem.resp_delim)
|
if (mon_ops->getmem.resp_delim)
|
compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
|
compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
|
getmem_resp_delim_fastmap);
|
getmem_resp_delim_fastmap);
|
|
|
unpush_target (targ_ops);
|
unpush_target (targ_ops);
|
|
|
if (dev_name)
|
if (dev_name)
|
free (dev_name);
|
free (dev_name);
|
dev_name = strsave (args);
|
dev_name = strsave (args);
|
|
|
monitor_desc = SERIAL_OPEN (dev_name);
|
monitor_desc = SERIAL_OPEN (dev_name);
|
|
|
if (!monitor_desc)
|
if (!monitor_desc)
|
perror_with_name (dev_name);
|
perror_with_name (dev_name);
|
|
|
if (baud_rate != -1)
|
if (baud_rate != -1)
|
{
|
{
|
if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
|
if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
|
{
|
{
|
SERIAL_CLOSE (monitor_desc);
|
SERIAL_CLOSE (monitor_desc);
|
perror_with_name (dev_name);
|
perror_with_name (dev_name);
|
}
|
}
|
}
|
}
|
|
|
SERIAL_RAW (monitor_desc);
|
SERIAL_RAW (monitor_desc);
|
|
|
SERIAL_FLUSH_INPUT (monitor_desc);
|
SERIAL_FLUSH_INPUT (monitor_desc);
|
|
|
/* some systems only work with 2 stop bits */
|
/* some systems only work with 2 stop bits */
|
|
|
SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
|
SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
|
|
|
current_monitor = mon_ops;
|
current_monitor = mon_ops;
|
|
|
/* See if we can wake up the monitor. First, try sending a stop sequence,
|
/* See if we can wake up the monitor. First, try sending a stop sequence,
|
then send the init strings. Last, remove all breakpoints. */
|
then send the init strings. Last, remove all breakpoints. */
|
|
|
if (current_monitor->stop)
|
if (current_monitor->stop)
|
{
|
{
|
monitor_stop ();
|
monitor_stop ();
|
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
|
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
|
{
|
{
|
monitor_debug ("EXP Open echo\n");
|
monitor_debug ("EXP Open echo\n");
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
}
|
}
|
|
|
/* wake up the monitor and see if it's alive */
|
/* wake up the monitor and see if it's alive */
|
for (p = mon_ops->init; *p != NULL; p++)
|
for (p = mon_ops->init; *p != NULL; p++)
|
{
|
{
|
/* Some of the characters we send may not be echoed,
|
/* Some of the characters we send may not be echoed,
|
but we hope to get a prompt at the end of it all. */
|
but we hope to get a prompt at the end of it all. */
|
|
|
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
|
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
|
monitor_printf (*p);
|
monitor_printf (*p);
|
else
|
else
|
monitor_printf_noecho (*p);
|
monitor_printf_noecho (*p);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
|
|
SERIAL_FLUSH_INPUT (monitor_desc);
|
SERIAL_FLUSH_INPUT (monitor_desc);
|
|
|
/* Alloc breakpoints */
|
/* Alloc breakpoints */
|
if (mon_ops->set_break != NULL)
|
if (mon_ops->set_break != NULL)
|
{
|
{
|
if (mon_ops->num_breakpoints == 0)
|
if (mon_ops->num_breakpoints == 0)
|
mon_ops->num_breakpoints = 8;
|
mon_ops->num_breakpoints = 8;
|
|
|
breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
|
breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
|
memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
|
memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
|
}
|
}
|
|
|
/* Remove all breakpoints */
|
/* Remove all breakpoints */
|
|
|
if (mon_ops->clr_all_break)
|
if (mon_ops->clr_all_break)
|
{
|
{
|
monitor_printf (mon_ops->clr_all_break);
|
monitor_printf (mon_ops->clr_all_break);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
|
|
if (from_tty)
|
if (from_tty)
|
printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
|
printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
|
|
|
push_target (targ_ops);
|
push_target (targ_ops);
|
|
|
inferior_pid = 42000; /* Make run command think we are busy... */
|
inferior_pid = 42000; /* Make run command think we are busy... */
|
|
|
/* Give monitor_wait something to read */
|
/* Give monitor_wait something to read */
|
|
|
monitor_printf (current_monitor->line_term);
|
monitor_printf (current_monitor->line_term);
|
|
|
if (current_monitor->flags & MO_HAS_BLOCKWRITES)
|
if (current_monitor->flags & MO_HAS_BLOCKWRITES)
|
remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
|
remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
|
else
|
else
|
remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
|
remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
|
start_remote ();
|
start_remote ();
|
}
|
}
|
|
|
/* Close out all files and local state before this target loses
|
/* Close out all files and local state before this target loses
|
control. */
|
control. */
|
|
|
void
|
void
|
monitor_close (quitting)
|
monitor_close (quitting)
|
int quitting;
|
int quitting;
|
{
|
{
|
if (monitor_desc)
|
if (monitor_desc)
|
SERIAL_CLOSE (monitor_desc);
|
SERIAL_CLOSE (monitor_desc);
|
|
|
/* Free breakpoint memory */
|
/* Free breakpoint memory */
|
if (breakaddr != NULL)
|
if (breakaddr != NULL)
|
{
|
{
|
free (breakaddr);
|
free (breakaddr);
|
breakaddr = NULL;
|
breakaddr = NULL;
|
}
|
}
|
|
|
monitor_desc = NULL;
|
monitor_desc = NULL;
|
}
|
}
|
|
|
/* Terminate the open connection to the remote debugger. Use this
|
/* Terminate the open connection to the remote debugger. Use this
|
when you want to detach and do something else with your gdb. */
|
when you want to detach and do something else with your gdb. */
|
|
|
static void
|
static void
|
monitor_detach (args, from_tty)
|
monitor_detach (args, from_tty)
|
char *args;
|
char *args;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
pop_target (); /* calls monitor_close to do the real work */
|
pop_target (); /* calls monitor_close to do the real work */
|
if (from_tty)
|
if (from_tty)
|
printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
|
printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
|
}
|
}
|
|
|
/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
|
/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
|
|
|
char *
|
char *
|
monitor_supply_register (regno, valstr)
|
monitor_supply_register (regno, valstr)
|
int regno;
|
int regno;
|
char *valstr;
|
char *valstr;
|
{
|
{
|
ULONGEST val;
|
ULONGEST val;
|
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
|
unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
|
char *p;
|
char *p;
|
|
|
val = 0;
|
val = 0;
|
p = valstr;
|
p = valstr;
|
while (p && *p != '\0')
|
while (p && *p != '\0')
|
{
|
{
|
if (*p == '\r' || *p == '\n')
|
if (*p == '\r' || *p == '\n')
|
{
|
{
|
while (*p != '\0')
|
while (*p != '\0')
|
p++;
|
p++;
|
break;
|
break;
|
}
|
}
|
if (isspace (*p))
|
if (isspace (*p))
|
{
|
{
|
p++;
|
p++;
|
continue;
|
continue;
|
}
|
}
|
if (!isxdigit (*p) && *p != 'x')
|
if (!isxdigit (*p) && *p != 'x')
|
{
|
{
|
break;
|
break;
|
}
|
}
|
|
|
val <<= 4;
|
val <<= 4;
|
val += fromhex (*p++);
|
val += fromhex (*p++);
|
}
|
}
|
monitor_debug ("Supplying Register %d %s\n", regno, valstr);
|
monitor_debug ("Supplying Register %d %s\n", regno, valstr);
|
|
|
if (*p != '\0')
|
if (*p != '\0')
|
error ("monitor_supply_register (%d): bad value from monitor: %s.",
|
error ("monitor_supply_register (%d): bad value from monitor: %s.",
|
regno, valstr);
|
regno, valstr);
|
|
|
/* supply register stores in target byte order, so swap here */
|
/* supply register stores in target byte order, so swap here */
|
|
|
store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
|
store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
|
|
|
supply_register (regno, regbuf);
|
supply_register (regno, regbuf);
|
|
|
return p;
|
return p;
|
}
|
}
|
|
|
/* Tell the remote machine to resume. */
|
/* Tell the remote machine to resume. */
|
|
|
void
|
void
|
flush_monitor_dcache ()
|
flush_monitor_dcache ()
|
{
|
{
|
dcache_flush (remote_dcache);
|
dcache_flush (remote_dcache);
|
}
|
}
|
|
|
static void
|
static void
|
monitor_resume (pid, step, sig)
|
monitor_resume (pid, step, sig)
|
int pid, step;
|
int pid, step;
|
enum target_signal sig;
|
enum target_signal sig;
|
{
|
{
|
/* Some monitors require a different command when starting a program */
|
/* Some monitors require a different command when starting a program */
|
monitor_debug ("MON resume\n");
|
monitor_debug ("MON resume\n");
|
if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
|
if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
|
{
|
{
|
first_time = 0;
|
first_time = 0;
|
monitor_printf ("run\r");
|
monitor_printf ("run\r");
|
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
|
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
|
dump_reg_flag = 1;
|
dump_reg_flag = 1;
|
return;
|
return;
|
}
|
}
|
dcache_flush (remote_dcache);
|
dcache_flush (remote_dcache);
|
if (step)
|
if (step)
|
monitor_printf (current_monitor->step);
|
monitor_printf (current_monitor->step);
|
else
|
else
|
{
|
{
|
if (current_monitor->continue_hook)
|
if (current_monitor->continue_hook)
|
(*current_monitor->continue_hook) ();
|
(*current_monitor->continue_hook) ();
|
else
|
else
|
monitor_printf (current_monitor->cont);
|
monitor_printf (current_monitor->cont);
|
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
|
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
|
dump_reg_flag = 1;
|
dump_reg_flag = 1;
|
}
|
}
|
}
|
}
|
|
|
/* Parse the output of a register dump command. A monitor specific
|
/* Parse the output of a register dump command. A monitor specific
|
regexp is used to extract individual register descriptions of the
|
regexp is used to extract individual register descriptions of the
|
form REG=VAL. Each description is split up into a name and a value
|
form REG=VAL. Each description is split up into a name and a value
|
string which are passed down to monitor specific code. */
|
string which are passed down to monitor specific code. */
|
|
|
static void
|
static void
|
parse_register_dump (buf, len)
|
parse_register_dump (buf, len)
|
char *buf;
|
char *buf;
|
int len;
|
int len;
|
{
|
{
|
monitor_debug ("MON Parsing register dump\n");
|
monitor_debug ("MON Parsing register dump\n");
|
while (1)
|
while (1)
|
{
|
{
|
int regnamelen, vallen;
|
int regnamelen, vallen;
|
char *regname, *val;
|
char *regname, *val;
|
/* Element 0 points to start of register name, and element 1
|
/* Element 0 points to start of register name, and element 1
|
points to the start of the register value. */
|
points to the start of the register value. */
|
struct re_registers register_strings;
|
struct re_registers register_strings;
|
|
|
memset (®ister_strings, 0, sizeof (struct re_registers));
|
memset (®ister_strings, 0, sizeof (struct re_registers));
|
|
|
if (re_search (®ister_pattern, buf, len, 0, len,
|
if (re_search (®ister_pattern, buf, len, 0, len,
|
®ister_strings) == -1)
|
®ister_strings) == -1)
|
break;
|
break;
|
|
|
regnamelen = register_strings.end[1] - register_strings.start[1];
|
regnamelen = register_strings.end[1] - register_strings.start[1];
|
regname = buf + register_strings.start[1];
|
regname = buf + register_strings.start[1];
|
vallen = register_strings.end[2] - register_strings.start[2];
|
vallen = register_strings.end[2] - register_strings.start[2];
|
val = buf + register_strings.start[2];
|
val = buf + register_strings.start[2];
|
|
|
current_monitor->supply_register (regname, regnamelen, val, vallen);
|
current_monitor->supply_register (regname, regnamelen, val, vallen);
|
|
|
buf += register_strings.end[0];
|
buf += register_strings.end[0];
|
len -= register_strings.end[0];
|
len -= register_strings.end[0];
|
}
|
}
|
}
|
}
|
|
|
/* Send ^C to target to halt it. Target will respond, and send us a
|
/* Send ^C to target to halt it. Target will respond, and send us a
|
packet. */
|
packet. */
|
|
|
static void
|
static void
|
monitor_interrupt (signo)
|
monitor_interrupt (signo)
|
int signo;
|
int signo;
|
{
|
{
|
/* If this doesn't work, try more severe steps. */
|
/* If this doesn't work, try more severe steps. */
|
signal (signo, monitor_interrupt_twice);
|
signal (signo, monitor_interrupt_twice);
|
|
|
if (monitor_debug_p || remote_debug)
|
if (monitor_debug_p || remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
|
fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
|
|
|
target_stop ();
|
target_stop ();
|
}
|
}
|
|
|
/* The user typed ^C twice. */
|
/* The user typed ^C twice. */
|
|
|
static void
|
static void
|
monitor_interrupt_twice (signo)
|
monitor_interrupt_twice (signo)
|
int signo;
|
int signo;
|
{
|
{
|
signal (signo, ofunc);
|
signal (signo, ofunc);
|
|
|
monitor_interrupt_query ();
|
monitor_interrupt_query ();
|
|
|
signal (signo, monitor_interrupt);
|
signal (signo, monitor_interrupt);
|
}
|
}
|
|
|
/* Ask the user what to do when an interrupt is received. */
|
/* Ask the user what to do when an interrupt is received. */
|
|
|
static void
|
static void
|
monitor_interrupt_query ()
|
monitor_interrupt_query ()
|
{
|
{
|
target_terminal_ours ();
|
target_terminal_ours ();
|
|
|
if (query ("Interrupted while waiting for the program.\n\
|
if (query ("Interrupted while waiting for the program.\n\
|
Give up (and stop debugging it)? "))
|
Give up (and stop debugging it)? "))
|
{
|
{
|
target_mourn_inferior ();
|
target_mourn_inferior ();
|
return_to_top_level (RETURN_QUIT);
|
return_to_top_level (RETURN_QUIT);
|
}
|
}
|
|
|
target_terminal_inferior ();
|
target_terminal_inferior ();
|
}
|
}
|
|
|
static void
|
static void
|
monitor_wait_cleanup (old_timeout)
|
monitor_wait_cleanup (old_timeout)
|
void *old_timeout;
|
void *old_timeout;
|
{
|
{
|
timeout = *(int *) old_timeout;
|
timeout = *(int *) old_timeout;
|
signal (SIGINT, ofunc);
|
signal (SIGINT, ofunc);
|
in_monitor_wait = 0;
|
in_monitor_wait = 0;
|
}
|
}
|
|
|
|
|
|
|
void
|
void
|
monitor_wait_filter (char *buf,
|
monitor_wait_filter (char *buf,
|
int bufmax,
|
int bufmax,
|
int *ext_resp_len,
|
int *ext_resp_len,
|
struct target_waitstatus *status
|
struct target_waitstatus *status
|
)
|
)
|
{
|
{
|
int resp_len;
|
int resp_len;
|
do
|
do
|
{
|
{
|
resp_len = monitor_expect_prompt (buf, bufmax);
|
resp_len = monitor_expect_prompt (buf, bufmax);
|
*ext_resp_len = resp_len;
|
*ext_resp_len = resp_len;
|
|
|
if (resp_len <= 0)
|
if (resp_len <= 0)
|
fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
|
fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
|
}
|
}
|
while (resp_len < 0);
|
while (resp_len < 0);
|
|
|
/* Print any output characters that were preceded by ^O. */
|
/* Print any output characters that were preceded by ^O. */
|
/* FIXME - This would be great as a user settabgle flag */
|
/* FIXME - This would be great as a user settabgle flag */
|
if (monitor_debug_p || remote_debug
|
if (monitor_debug_p || remote_debug
|
|| current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
|
|| current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < resp_len - 1; i++)
|
for (i = 0; i < resp_len - 1; i++)
|
if (buf[i] == 0x0f)
|
if (buf[i] == 0x0f)
|
putchar_unfiltered (buf[++i]);
|
putchar_unfiltered (buf[++i]);
|
}
|
}
|
}
|
}
|
|
|
|
|
|
|
/* Wait until the remote machine stops, then return, storing status in
|
/* Wait until the remote machine stops, then return, storing status in
|
status just as `wait' would. */
|
status just as `wait' would. */
|
|
|
static int
|
static int
|
monitor_wait (pid, status)
|
monitor_wait (pid, status)
|
int pid;
|
int pid;
|
struct target_waitstatus *status;
|
struct target_waitstatus *status;
|
{
|
{
|
int old_timeout = timeout;
|
int old_timeout = timeout;
|
char buf[TARGET_BUF_SIZE];
|
char buf[TARGET_BUF_SIZE];
|
int resp_len;
|
int resp_len;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
|
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->kind = TARGET_WAITKIND_EXITED;
|
status->value.integer = 0;
|
status->value.integer = 0;
|
|
|
old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
|
old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
|
monitor_debug ("MON wait\n");
|
monitor_debug ("MON wait\n");
|
|
|
#if 0
|
#if 0
|
/* This is somthing other than a maintenance command */
|
/* This is somthing other than a maintenance command */
|
in_monitor_wait = 1;
|
in_monitor_wait = 1;
|
timeout = watchdog > 0 ? watchdog : -1;
|
timeout = watchdog > 0 ? watchdog : -1;
|
#else
|
#else
|
timeout = -1; /* Don't time out -- user program is running. */
|
timeout = -1; /* Don't time out -- user program is running. */
|
#endif
|
#endif
|
|
|
ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
|
ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
|
|
|
if (current_monitor->wait_filter)
|
if (current_monitor->wait_filter)
|
(*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
|
(*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
|
else
|
else
|
monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
|
monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
|
|
|
#if 0 /* Transferred to monitor wait filter */
|
#if 0 /* Transferred to monitor wait filter */
|
do
|
do
|
{
|
{
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
|
|
if (resp_len <= 0)
|
if (resp_len <= 0)
|
fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
|
fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
|
}
|
}
|
while (resp_len < 0);
|
while (resp_len < 0);
|
|
|
/* Print any output characters that were preceded by ^O. */
|
/* Print any output characters that were preceded by ^O. */
|
/* FIXME - This would be great as a user settabgle flag */
|
/* FIXME - This would be great as a user settabgle flag */
|
if (monitor_debug_p || remote_debug
|
if (monitor_debug_p || remote_debug
|
|| current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
|
|| current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
|
{
|
{
|
int i;
|
int i;
|
|
|
for (i = 0; i < resp_len - 1; i++)
|
for (i = 0; i < resp_len - 1; i++)
|
if (buf[i] == 0x0f)
|
if (buf[i] == 0x0f)
|
putchar_unfiltered (buf[++i]);
|
putchar_unfiltered (buf[++i]);
|
}
|
}
|
#endif
|
#endif
|
|
|
signal (SIGINT, ofunc);
|
signal (SIGINT, ofunc);
|
|
|
timeout = old_timeout;
|
timeout = old_timeout;
|
#if 0
|
#if 0
|
if (dump_reg_flag && current_monitor->dump_registers)
|
if (dump_reg_flag && current_monitor->dump_registers)
|
{
|
{
|
dump_reg_flag = 0;
|
dump_reg_flag = 0;
|
monitor_printf (current_monitor->dump_registers);
|
monitor_printf (current_monitor->dump_registers);
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
}
|
}
|
|
|
if (current_monitor->register_pattern)
|
if (current_monitor->register_pattern)
|
parse_register_dump (buf, resp_len);
|
parse_register_dump (buf, resp_len);
|
#else
|
#else
|
monitor_debug ("Wait fetching registers after stop\n");
|
monitor_debug ("Wait fetching registers after stop\n");
|
monitor_dump_regs ();
|
monitor_dump_regs ();
|
#endif
|
#endif
|
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->kind = TARGET_WAITKIND_STOPPED;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
|
|
discard_cleanups (old_chain);
|
discard_cleanups (old_chain);
|
|
|
in_monitor_wait = 0;
|
in_monitor_wait = 0;
|
|
|
return inferior_pid;
|
return inferior_pid;
|
}
|
}
|
|
|
/* Fetch register REGNO, or all registers if REGNO is -1. Returns
|
/* Fetch register REGNO, or all registers if REGNO is -1. Returns
|
errno value. */
|
errno value. */
|
|
|
static void
|
static void
|
monitor_fetch_register (regno)
|
monitor_fetch_register (regno)
|
int regno;
|
int regno;
|
{
|
{
|
char *name;
|
char *name;
|
static char zerobuf[MAX_REGISTER_RAW_SIZE] =
|
static char zerobuf[MAX_REGISTER_RAW_SIZE] =
|
{0};
|
{0};
|
char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
|
char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
|
int i;
|
int i;
|
|
|
name = current_monitor->regnames[regno];
|
name = current_monitor->regnames[regno];
|
monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
|
monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
|
|
|
if (!name || (*name == '\0'))
|
if (!name || (*name == '\0'))
|
{
|
{
|
monitor_debug ("No register known for %d\n", regno);
|
monitor_debug ("No register known for %d\n", regno);
|
supply_register (regno, zerobuf);
|
supply_register (regno, zerobuf);
|
return;
|
return;
|
}
|
}
|
|
|
/* send the register examine command */
|
/* send the register examine command */
|
|
|
monitor_printf (current_monitor->getreg.cmd, name);
|
monitor_printf (current_monitor->getreg.cmd, name);
|
|
|
/* If RESP_DELIM is specified, we search for that as a leading
|
/* If RESP_DELIM is specified, we search for that as a leading
|
delimiter for the register value. Otherwise, we just start
|
delimiter for the register value. Otherwise, we just start
|
searching from the start of the buf. */
|
searching from the start of the buf. */
|
|
|
if (current_monitor->getreg.resp_delim)
|
if (current_monitor->getreg.resp_delim)
|
{
|
{
|
monitor_debug ("EXP getreg.resp_delim\n");
|
monitor_debug ("EXP getreg.resp_delim\n");
|
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
|
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
|
/* Handle case of first 32 registers listed in pairs. */
|
/* Handle case of first 32 registers listed in pairs. */
|
if (current_monitor->flags & MO_32_REGS_PAIRED
|
if (current_monitor->flags & MO_32_REGS_PAIRED
|
&& (regno & 1) != 0 && regno < 32)
|
&& (regno & 1) != 0 && regno < 32)
|
{
|
{
|
monitor_debug ("EXP getreg.resp_delim\n");
|
monitor_debug ("EXP getreg.resp_delim\n");
|
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
|
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
|
}
|
}
|
}
|
}
|
|
|
/* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
|
/* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
|
if (current_monitor->flags & MO_HEX_PREFIX)
|
if (current_monitor->flags & MO_HEX_PREFIX)
|
{
|
{
|
int c;
|
int c;
|
c = readchar (timeout);
|
c = readchar (timeout);
|
while (c == ' ')
|
while (c == ' ')
|
c = readchar (timeout);
|
c = readchar (timeout);
|
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
|
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
|
;
|
;
|
else
|
else
|
error ("Bad value returned from monitor while fetching register %x.",
|
error ("Bad value returned from monitor while fetching register %x.",
|
regno);
|
regno);
|
}
|
}
|
|
|
/* Read upto the maximum number of hex digits for this register, skipping
|
/* Read upto the maximum number of hex digits for this register, skipping
|
spaces, but stop reading if something else is seen. Some monitors
|
spaces, but stop reading if something else is seen. Some monitors
|
like to drop leading zeros. */
|
like to drop leading zeros. */
|
|
|
for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
|
for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
|
{
|
{
|
int c;
|
int c;
|
c = readchar (timeout);
|
c = readchar (timeout);
|
while (c == ' ')
|
while (c == ' ')
|
c = readchar (timeout);
|
c = readchar (timeout);
|
|
|
if (!isxdigit (c))
|
if (!isxdigit (c))
|
break;
|
break;
|
|
|
regbuf[i] = c;
|
regbuf[i] = c;
|
}
|
}
|
|
|
regbuf[i] = '\000'; /* terminate the number */
|
regbuf[i] = '\000'; /* terminate the number */
|
monitor_debug ("REGVAL '%s'\n", regbuf);
|
monitor_debug ("REGVAL '%s'\n", regbuf);
|
|
|
/* If TERM is present, we wait for that to show up. Also, (if TERM
|
/* 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
|
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
|
case, we collect all of the output into buf, and then wait for
|
the normal prompt. */
|
the normal prompt. */
|
|
|
if (current_monitor->getreg.term)
|
if (current_monitor->getreg.term)
|
{
|
{
|
monitor_debug ("EXP getreg.term\n");
|
monitor_debug ("EXP getreg.term\n");
|
monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
|
monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
|
}
|
}
|
|
|
if (current_monitor->getreg.term_cmd)
|
if (current_monitor->getreg.term_cmd)
|
{
|
{
|
monitor_debug ("EMIT getreg.term.cmd\n");
|
monitor_debug ("EMIT getreg.term.cmd\n");
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_printf (current_monitor->getreg.term_cmd);
|
}
|
}
|
if (!current_monitor->getreg.term || /* Already expected or */
|
if (!current_monitor->getreg.term || /* Already expected or */
|
current_monitor->getreg.term_cmd) /* ack expected */
|
current_monitor->getreg.term_cmd) /* ack expected */
|
monitor_expect_prompt (NULL, 0); /* get response */
|
monitor_expect_prompt (NULL, 0); /* get response */
|
|
|
monitor_supply_register (regno, regbuf);
|
monitor_supply_register (regno, regbuf);
|
}
|
}
|
|
|
/* Sometimes, it takes several commands to dump the registers */
|
/* Sometimes, it takes several commands to dump the registers */
|
/* This is a primitive for use by variations of monitor interfaces in
|
/* This is a primitive for use by variations of monitor interfaces in
|
case they need to compose the operation.
|
case they need to compose the operation.
|
*/
|
*/
|
int
|
int
|
monitor_dump_reg_block (char *block_cmd)
|
monitor_dump_reg_block (char *block_cmd)
|
{
|
{
|
char buf[TARGET_BUF_SIZE];
|
char buf[TARGET_BUF_SIZE];
|
int resp_len;
|
int resp_len;
|
monitor_printf (block_cmd);
|
monitor_printf (block_cmd);
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
parse_register_dump (buf, resp_len);
|
parse_register_dump (buf, resp_len);
|
return 1;
|
return 1;
|
}
|
}
|
|
|
|
|
/* Read the remote registers into the block regs. */
|
/* Read the remote registers into the block regs. */
|
/* Call the specific function if it has been provided */
|
/* Call the specific function if it has been provided */
|
|
|
static void
|
static void
|
monitor_dump_regs ()
|
monitor_dump_regs ()
|
{
|
{
|
char buf[TARGET_BUF_SIZE];
|
char buf[TARGET_BUF_SIZE];
|
int resp_len;
|
int resp_len;
|
if (current_monitor->dumpregs)
|
if (current_monitor->dumpregs)
|
(*(current_monitor->dumpregs)) (); /* call supplied function */
|
(*(current_monitor->dumpregs)) (); /* call supplied function */
|
else if (current_monitor->dump_registers) /* default version */
|
else if (current_monitor->dump_registers) /* default version */
|
{
|
{
|
monitor_printf (current_monitor->dump_registers);
|
monitor_printf (current_monitor->dump_registers);
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
parse_register_dump (buf, resp_len);
|
parse_register_dump (buf, resp_len);
|
}
|
}
|
else
|
else
|
abort (); /* Need some way to read registers */
|
abort (); /* Need some way to read registers */
|
}
|
}
|
|
|
static void
|
static void
|
monitor_fetch_registers (regno)
|
monitor_fetch_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
monitor_debug ("MON fetchregs\n");
|
monitor_debug ("MON fetchregs\n");
|
if (current_monitor->getreg.cmd)
|
if (current_monitor->getreg.cmd)
|
{
|
{
|
if (regno >= 0)
|
if (regno >= 0)
|
{
|
{
|
monitor_fetch_register (regno);
|
monitor_fetch_register (regno);
|
return;
|
return;
|
}
|
}
|
|
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
monitor_fetch_register (regno);
|
monitor_fetch_register (regno);
|
}
|
}
|
else
|
else
|
{
|
{
|
monitor_dump_regs ();
|
monitor_dump_regs ();
|
}
|
}
|
}
|
}
|
|
|
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
|
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
|
|
|
static void
|
static void
|
monitor_store_register (regno)
|
monitor_store_register (regno)
|
int regno;
|
int regno;
|
{
|
{
|
char *name;
|
char *name;
|
ULONGEST val;
|
ULONGEST val;
|
|
|
name = current_monitor->regnames[regno];
|
name = current_monitor->regnames[regno];
|
if (!name || (*name == '\0'))
|
if (!name || (*name == '\0'))
|
{
|
{
|
monitor_debug ("MON Cannot store unknown register\n");
|
monitor_debug ("MON Cannot store unknown register\n");
|
return;
|
return;
|
}
|
}
|
|
|
val = read_register (regno);
|
val = read_register (regno);
|
monitor_debug ("MON storeg %d %s\n", regno, preg (val));
|
monitor_debug ("MON storeg %d %s\n", regno, preg (val));
|
|
|
/* send the register deposit command */
|
/* send the register deposit command */
|
|
|
if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
|
if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
|
monitor_printf (current_monitor->setreg.cmd, val, name);
|
monitor_printf (current_monitor->setreg.cmd, val, name);
|
else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
monitor_printf (current_monitor->setreg.cmd, name);
|
monitor_printf (current_monitor->setreg.cmd, name);
|
else
|
else
|
monitor_printf (current_monitor->setreg.cmd, name, val);
|
monitor_printf (current_monitor->setreg.cmd, name, val);
|
|
|
if (current_monitor->setreg.term)
|
if (current_monitor->setreg.term)
|
{
|
{
|
monitor_debug ("EXP setreg.term\n");
|
monitor_debug ("EXP setreg.term\n");
|
monitor_expect (current_monitor->setreg.term, NULL, 0);
|
monitor_expect (current_monitor->setreg.term, NULL, 0);
|
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
monitor_printf ("%s\r", paddr_nz (val));
|
monitor_printf ("%s\r", paddr_nz (val));
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
else
|
else
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
if (current_monitor->setreg.term_cmd) /* Mode exit required */
|
if (current_monitor->setreg.term_cmd) /* Mode exit required */
|
{
|
{
|
monitor_debug ("EXP setreg_termcmd\n");
|
monitor_debug ("EXP setreg_termcmd\n");
|
monitor_printf ("%s", current_monitor->setreg.term_cmd);
|
monitor_printf ("%s", current_monitor->setreg.term_cmd);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
} /* monitor_store_register */
|
} /* monitor_store_register */
|
|
|
/* Store the remote registers. */
|
/* Store the remote registers. */
|
|
|
static void
|
static void
|
monitor_store_registers (regno)
|
monitor_store_registers (regno)
|
int regno;
|
int regno;
|
{
|
{
|
if (regno >= 0)
|
if (regno >= 0)
|
{
|
{
|
monitor_store_register (regno);
|
monitor_store_register (regno);
|
return;
|
return;
|
}
|
}
|
|
|
for (regno = 0; regno < NUM_REGS; regno++)
|
for (regno = 0; regno < NUM_REGS; regno++)
|
monitor_store_register (regno);
|
monitor_store_register (regno);
|
}
|
}
|
|
|
/* Get ready to modify the registers array. On machines which store
|
/* Get ready to modify the registers array. On machines which store
|
individual registers, this doesn't need to do anything. On machines
|
individual registers, this doesn't need to do anything. On machines
|
which store all the registers in one fell swoop, this makes sure
|
which store all the registers in one fell swoop, this makes sure
|
that registers contains all the registers from the program being
|
that registers contains all the registers from the program being
|
debugged. */
|
debugged. */
|
|
|
static void
|
static void
|
monitor_prepare_to_store ()
|
monitor_prepare_to_store ()
|
{
|
{
|
/* Do nothing, since we can store individual regs */
|
/* Do nothing, since we can store individual regs */
|
}
|
}
|
|
|
static void
|
static void
|
monitor_files_info (ops)
|
monitor_files_info (ops)
|
struct target_ops *ops;
|
struct target_ops *ops;
|
{
|
{
|
printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
|
printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
|
}
|
}
|
|
|
static int
|
static int
|
monitor_write_memory (memaddr, myaddr, len)
|
monitor_write_memory (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
unsigned int val, hostval;
|
unsigned int val, hostval;
|
char *cmd;
|
char *cmd;
|
int i;
|
int i;
|
|
|
monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
|
monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
|
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
memaddr = ADDR_BITS_REMOVE (memaddr);
|
memaddr = ADDR_BITS_REMOVE (memaddr);
|
|
|
/* Use memory fill command for leading 0 bytes. */
|
/* Use memory fill command for leading 0 bytes. */
|
|
|
if (current_monitor->fill)
|
if (current_monitor->fill)
|
{
|
{
|
for (i = 0; i < len; i++)
|
for (i = 0; i < len; i++)
|
if (myaddr[i] != 0)
|
if (myaddr[i] != 0)
|
break;
|
break;
|
|
|
if (i > 4) /* More than 4 zeros is worth doing */
|
if (i > 4) /* More than 4 zeros is worth doing */
|
{
|
{
|
monitor_debug ("MON FILL %d\n", i);
|
monitor_debug ("MON FILL %d\n", i);
|
if (current_monitor->flags & MO_FILL_USES_ADDR)
|
if (current_monitor->flags & MO_FILL_USES_ADDR)
|
monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
|
monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
|
else
|
else
|
monitor_printf (current_monitor->fill, memaddr, i, 0);
|
monitor_printf (current_monitor->fill, memaddr, i, 0);
|
|
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
|
|
return i;
|
return i;
|
}
|
}
|
}
|
}
|
|
|
#if 0
|
#if 0
|
/* Can't actually use long longs if VAL is an int (nice idea, though). */
|
/* Can't actually use long longs if VAL is an int (nice idea, though). */
|
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
|
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
|
{
|
{
|
len = 8;
|
len = 8;
|
cmd = current_monitor->setmem.cmdll;
|
cmd = current_monitor->setmem.cmdll;
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
|
if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
|
{
|
{
|
len = 4;
|
len = 4;
|
cmd = current_monitor->setmem.cmdl;
|
cmd = current_monitor->setmem.cmdl;
|
}
|
}
|
else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
|
else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
|
{
|
{
|
len = 2;
|
len = 2;
|
cmd = current_monitor->setmem.cmdw;
|
cmd = current_monitor->setmem.cmdw;
|
}
|
}
|
else
|
else
|
{
|
{
|
len = 1;
|
len = 1;
|
cmd = current_monitor->setmem.cmdb;
|
cmd = current_monitor->setmem.cmdb;
|
}
|
}
|
|
|
val = extract_unsigned_integer (myaddr, len);
|
val = extract_unsigned_integer (myaddr, len);
|
|
|
if (len == 4)
|
if (len == 4)
|
{
|
{
|
hostval = *(unsigned int *) myaddr;
|
hostval = *(unsigned int *) myaddr;
|
monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
|
monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
|
}
|
}
|
|
|
|
|
if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
|
if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
|
monitor_printf_noecho (cmd, memaddr, val);
|
monitor_printf_noecho (cmd, memaddr, val);
|
else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
|
else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
|
{
|
{
|
|
|
monitor_printf_noecho (cmd, memaddr);
|
monitor_printf_noecho (cmd, memaddr);
|
|
|
if (current_monitor->setmem.term)
|
if (current_monitor->setmem.term)
|
{
|
{
|
monitor_debug ("EXP setmem.term");
|
monitor_debug ("EXP setmem.term");
|
monitor_expect (current_monitor->setmem.term, NULL, 0);
|
monitor_expect (current_monitor->setmem.term, NULL, 0);
|
monitor_printf ("%x\r", val);
|
monitor_printf ("%x\r", val);
|
}
|
}
|
if (current_monitor->setmem.term_cmd)
|
if (current_monitor->setmem.term_cmd)
|
{ /* Emit this to get out of the memory editing state */
|
{ /* Emit this to get out of the memory editing state */
|
monitor_printf ("%s", current_monitor->setmem.term_cmd);
|
monitor_printf ("%s", current_monitor->setmem.term_cmd);
|
/* Drop through to expecting a prompt */
|
/* Drop through to expecting a prompt */
|
}
|
}
|
}
|
}
|
else
|
else
|
monitor_printf (cmd, memaddr, val);
|
monitor_printf (cmd, memaddr, val);
|
|
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
|
|
static int
|
static int
|
monitor_write_even_block (memaddr, myaddr, len)
|
monitor_write_even_block (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
unsigned int val;
|
unsigned int val;
|
int written = 0;;
|
int written = 0;;
|
/* Enter the sub mode */
|
/* Enter the sub mode */
|
monitor_printf (current_monitor->setmem.cmdl, memaddr);
|
monitor_printf (current_monitor->setmem.cmdl, memaddr);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
|
|
while (len)
|
while (len)
|
{
|
{
|
val = extract_unsigned_integer (myaddr, 4); /* REALLY */
|
val = extract_unsigned_integer (myaddr, 4); /* REALLY */
|
monitor_printf ("%x\r", val);
|
monitor_printf ("%x\r", val);
|
myaddr += 4;
|
myaddr += 4;
|
memaddr += 4;
|
memaddr += 4;
|
written += 4;
|
written += 4;
|
monitor_debug (" @ %s\n", paddr (memaddr));
|
monitor_debug (" @ %s\n", paddr (memaddr));
|
/* If we wanted to, here we could validate the address */
|
/* If we wanted to, here we could validate the address */
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
/* Now exit the sub mode */
|
/* Now exit the sub mode */
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
return written;
|
return written;
|
}
|
}
|
|
|
|
|
static int
|
static int
|
monitor_write_memory_bytes (memaddr, myaddr, len)
|
monitor_write_memory_bytes (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
unsigned char val;
|
unsigned char val;
|
int written = 0;
|
int written = 0;
|
if (len == 0)
|
if (len == 0)
|
return 0;
|
return 0;
|
/* Enter the sub mode */
|
/* Enter the sub mode */
|
monitor_printf (current_monitor->setmem.cmdb, memaddr);
|
monitor_printf (current_monitor->setmem.cmdb, memaddr);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
while (len)
|
while (len)
|
{
|
{
|
val = *myaddr;
|
val = *myaddr;
|
monitor_printf ("%x\r", val);
|
monitor_printf ("%x\r", val);
|
myaddr++;
|
myaddr++;
|
memaddr++;
|
memaddr++;
|
written++;
|
written++;
|
/* If we wanted to, here we could validate the address */
|
/* If we wanted to, here we could validate the address */
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
len--;
|
len--;
|
}
|
}
|
/* Now exit the sub mode */
|
/* Now exit the sub mode */
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
return written;
|
return written;
|
}
|
}
|
|
|
|
|
static void
|
static void
|
longlongendswap (unsigned char *a)
|
longlongendswap (unsigned char *a)
|
{
|
{
|
int i, j;
|
int i, j;
|
unsigned char x;
|
unsigned char x;
|
i = 0;
|
i = 0;
|
j = 7;
|
j = 7;
|
while (i < 4)
|
while (i < 4)
|
{
|
{
|
x = *(a + i);
|
x = *(a + i);
|
*(a + i) = *(a + j);
|
*(a + i) = *(a + j);
|
*(a + j) = x;
|
*(a + j) = x;
|
i++, j--;
|
i++, j--;
|
}
|
}
|
}
|
}
|
/* Format 32 chars of long long value, advance the pointer */
|
/* Format 32 chars of long long value, advance the pointer */
|
static char *hexlate = "0123456789abcdef";
|
static char *hexlate = "0123456789abcdef";
|
static char *
|
static char *
|
longlong_hexchars (unsigned long long value,
|
longlong_hexchars (unsigned long long value,
|
char *outbuff)
|
char *outbuff)
|
{
|
{
|
if (value == 0)
|
if (value == 0)
|
{
|
{
|
*outbuff++ = '0';
|
*outbuff++ = '0';
|
return outbuff;
|
return outbuff;
|
}
|
}
|
else
|
else
|
{
|
{
|
static unsigned char disbuf[8]; /* disassembly buffer */
|
static unsigned char disbuf[8]; /* disassembly buffer */
|
unsigned char *scan, *limit; /* loop controls */
|
unsigned char *scan, *limit; /* loop controls */
|
unsigned char c, nib;
|
unsigned char c, nib;
|
int leadzero = 1;
|
int leadzero = 1;
|
scan = disbuf;
|
scan = disbuf;
|
limit = scan + 8;
|
limit = scan + 8;
|
{
|
{
|
unsigned long long *dp;
|
unsigned long long *dp;
|
dp = (unsigned long long *) scan;
|
dp = (unsigned long long *) scan;
|
*dp = value;
|
*dp = value;
|
}
|
}
|
longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
|
longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
|
while (scan < limit)
|
while (scan < limit)
|
{
|
{
|
c = *scan++; /* a byte of our long long value */
|
c = *scan++; /* a byte of our long long value */
|
if (leadzero)
|
if (leadzero)
|
{
|
{
|
if (c == 0)
|
if (c == 0)
|
continue;
|
continue;
|
else
|
else
|
leadzero = 0; /* henceforth we print even zeroes */
|
leadzero = 0; /* henceforth we print even zeroes */
|
}
|
}
|
nib = c >> 4; /* high nibble bits */
|
nib = c >> 4; /* high nibble bits */
|
*outbuff++ = hexlate[nib];
|
*outbuff++ = hexlate[nib];
|
nib = c & 0x0f; /* low nibble bits */
|
nib = c & 0x0f; /* low nibble bits */
|
*outbuff++ = hexlate[nib];
|
*outbuff++ = hexlate[nib];
|
}
|
}
|
return outbuff;
|
return outbuff;
|
}
|
}
|
} /* longlong_hexchars */
|
} /* longlong_hexchars */
|
|
|
|
|
|
|
/* I am only going to call this when writing virtual byte streams.
|
/* I am only going to call this when writing virtual byte streams.
|
Which possably entails endian conversions
|
Which possably entails endian conversions
|
*/
|
*/
|
static int
|
static int
|
monitor_write_memory_longlongs (memaddr, myaddr, len)
|
monitor_write_memory_longlongs (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
static char hexstage[20]; /* At least 16 digits required, plus null */
|
static char hexstage[20]; /* At least 16 digits required, plus null */
|
char *endstring;
|
char *endstring;
|
long long *llptr;
|
long long *llptr;
|
long long value;
|
long long value;
|
int written = 0;
|
int written = 0;
|
llptr = (unsigned long long *) myaddr;
|
llptr = (unsigned long long *) myaddr;
|
if (len == 0)
|
if (len == 0)
|
return 0;
|
return 0;
|
monitor_printf (current_monitor->setmem.cmdll, memaddr);
|
monitor_printf (current_monitor->setmem.cmdll, memaddr);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
while (len >= 8)
|
while (len >= 8)
|
{
|
{
|
value = *llptr;
|
value = *llptr;
|
endstring = longlong_hexchars (*llptr, hexstage);
|
endstring = longlong_hexchars (*llptr, hexstage);
|
*endstring = '\0'; /* NUll terminate for printf */
|
*endstring = '\0'; /* NUll terminate for printf */
|
monitor_printf ("%s\r", hexstage);
|
monitor_printf ("%s\r", hexstage);
|
llptr++;
|
llptr++;
|
memaddr += 8;
|
memaddr += 8;
|
written += 8;
|
written += 8;
|
/* If we wanted to, here we could validate the address */
|
/* If we wanted to, here we could validate the address */
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
len -= 8;
|
len -= 8;
|
}
|
}
|
/* Now exit the sub mode */
|
/* Now exit the sub mode */
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_printf (current_monitor->getreg.term_cmd);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
return written;
|
return written;
|
} /* */
|
} /* */
|
|
|
|
|
|
|
/* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
|
/* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
|
/* This is for the large blocks of memory which may occur in downloading.
|
/* This is for the large blocks of memory which may occur in downloading.
|
And for monitors which use interactive entry,
|
And for monitors which use interactive entry,
|
And for monitors which do not have other downloading methods.
|
And for monitors which do not have other downloading methods.
|
Without this, we will end up calling monitor_write_memory many times
|
Without this, we will end up calling monitor_write_memory many times
|
and do the entry and exit of the sub mode many times
|
and do the entry and exit of the sub mode many times
|
This currently assumes...
|
This currently assumes...
|
MO_SETMEM_INTERACTIVE
|
MO_SETMEM_INTERACTIVE
|
! MO_NO_ECHO_ON_SETMEM
|
! MO_NO_ECHO_ON_SETMEM
|
To use this, the you have to patch the monitor_cmds block with
|
To use this, the you have to patch the monitor_cmds block with
|
this function. Otherwise, its not tuned up for use by all
|
this function. Otherwise, its not tuned up for use by all
|
monitor variations.
|
monitor variations.
|
*/
|
*/
|
|
|
static int
|
static int
|
monitor_write_memory_block (memaddr, myaddr, len)
|
monitor_write_memory_block (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
int written;
|
int written;
|
written = 0;
|
written = 0;
|
/* FIXME: This would be a good place to put the zero test */
|
/* FIXME: This would be a good place to put the zero test */
|
#if 1
|
#if 1
|
if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
|
if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
|
{
|
{
|
return monitor_write_memory_longlongs (memaddr, myaddr, len);
|
return monitor_write_memory_longlongs (memaddr, myaddr, len);
|
}
|
}
|
#endif
|
#endif
|
#if 0
|
#if 0
|
if (len > 4)
|
if (len > 4)
|
{
|
{
|
int sublen;
|
int sublen;
|
written = monitor_write_even_block (memaddr, myaddr, len);
|
written = monitor_write_even_block (memaddr, myaddr, len);
|
/* Adjust calling parameters by written amount */
|
/* Adjust calling parameters by written amount */
|
memaddr += written;
|
memaddr += written;
|
myaddr += written;
|
myaddr += written;
|
len -= written;
|
len -= written;
|
}
|
}
|
#endif
|
#endif
|
written = monitor_write_memory_bytes (memaddr, myaddr, len);
|
written = monitor_write_memory_bytes (memaddr, myaddr, len);
|
return written;
|
return written;
|
}
|
}
|
|
|
/* This is an alternate form of monitor_read_memory which is used for monitors
|
/* This is an alternate form of monitor_read_memory which is used for monitors
|
which can only read a single byte/word/etc. at a time. */
|
which can only read a single byte/word/etc. at a time. */
|
|
|
static int
|
static int
|
monitor_read_memory_single (memaddr, myaddr, len)
|
monitor_read_memory_single (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
unsigned int val;
|
unsigned int val;
|
char membuf[sizeof (int) * 2 + 1];
|
char membuf[sizeof (int) * 2 + 1];
|
char *p;
|
char *p;
|
char *cmd;
|
char *cmd;
|
int i;
|
int i;
|
|
|
monitor_debug ("MON read single\n");
|
monitor_debug ("MON read single\n");
|
#if 0
|
#if 0
|
/* Can't actually use long longs (nice idea, though). In fact, the
|
/* 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
|
call to strtoul below will fail if it tries to convert a value
|
that's too big to fit in a long. */
|
that's too big to fit in a long. */
|
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
|
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
|
{
|
{
|
len = 8;
|
len = 8;
|
cmd = current_monitor->getmem.cmdll;
|
cmd = current_monitor->getmem.cmdll;
|
}
|
}
|
else
|
else
|
#endif
|
#endif
|
if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
|
if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
|
{
|
{
|
len = 4;
|
len = 4;
|
cmd = current_monitor->getmem.cmdl;
|
cmd = current_monitor->getmem.cmdl;
|
}
|
}
|
else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
|
else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
|
{
|
{
|
len = 2;
|
len = 2;
|
cmd = current_monitor->getmem.cmdw;
|
cmd = current_monitor->getmem.cmdw;
|
}
|
}
|
else
|
else
|
{
|
{
|
len = 1;
|
len = 1;
|
cmd = current_monitor->getmem.cmdb;
|
cmd = current_monitor->getmem.cmdb;
|
}
|
}
|
|
|
/* Send the examine command. */
|
/* Send the examine command. */
|
|
|
monitor_printf (cmd, memaddr);
|
monitor_printf (cmd, memaddr);
|
|
|
/* If RESP_DELIM is specified, we search for that as a leading
|
/* If RESP_DELIM is specified, we search for that as a leading
|
delimiter for the memory value. Otherwise, we just start
|
delimiter for the memory value. Otherwise, we just start
|
searching from the start of the buf. */
|
searching from the start of the buf. */
|
|
|
if (current_monitor->getmem.resp_delim)
|
if (current_monitor->getmem.resp_delim)
|
{
|
{
|
monitor_debug ("EXP getmem.resp_delim\n");
|
monitor_debug ("EXP getmem.resp_delim\n");
|
monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
|
monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
|
}
|
}
|
|
|
/* Now, read the appropriate number of hex digits for this loc,
|
/* Now, read the appropriate number of hex digits for this loc,
|
skipping spaces. */
|
skipping spaces. */
|
|
|
/* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
|
/* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
|
if (current_monitor->flags & MO_HEX_PREFIX)
|
if (current_monitor->flags & MO_HEX_PREFIX)
|
{
|
{
|
int c;
|
int c;
|
|
|
c = readchar (timeout);
|
c = readchar (timeout);
|
while (c == ' ')
|
while (c == ' ')
|
c = readchar (timeout);
|
c = readchar (timeout);
|
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
|
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
|
;
|
;
|
else
|
else
|
monitor_error ("monitor_read_memory_single",
|
monitor_error ("monitor_read_memory_single",
|
"bad response from monitor",
|
"bad response from monitor",
|
memaddr, i, membuf, c);
|
memaddr, i, membuf, c);
|
}
|
}
|
for (i = 0; i < len * 2; i++)
|
for (i = 0; i < len * 2; i++)
|
{
|
{
|
int c;
|
int c;
|
|
|
while (1)
|
while (1)
|
{
|
{
|
c = readchar (timeout);
|
c = readchar (timeout);
|
if (isxdigit (c))
|
if (isxdigit (c))
|
break;
|
break;
|
if (c == ' ')
|
if (c == ' ')
|
continue;
|
continue;
|
|
|
monitor_error ("monitor_read_memory_single",
|
monitor_error ("monitor_read_memory_single",
|
"bad response from monitor",
|
"bad response from monitor",
|
memaddr, i, membuf, c);
|
memaddr, i, membuf, c);
|
}
|
}
|
|
|
membuf[i] = c;
|
membuf[i] = c;
|
}
|
}
|
|
|
membuf[i] = '\000'; /* terminate the number */
|
membuf[i] = '\000'; /* terminate the number */
|
|
|
/* If TERM is present, we wait for that to show up. Also, (if TERM is
|
/* 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
|
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. */
|
all of the output into buf, and then wait for the normal prompt. */
|
|
|
if (current_monitor->getmem.term)
|
if (current_monitor->getmem.term)
|
{
|
{
|
monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
|
monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
|
|
|
if (current_monitor->getmem.term_cmd)
|
if (current_monitor->getmem.term_cmd)
|
{
|
{
|
monitor_printf (current_monitor->getmem.term_cmd);
|
monitor_printf (current_monitor->getmem.term_cmd);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
}
|
}
|
else
|
else
|
monitor_expect_prompt (NULL, 0); /* get response */
|
monitor_expect_prompt (NULL, 0); /* get response */
|
|
|
p = membuf;
|
p = membuf;
|
val = strtoul (membuf, &p, 16);
|
val = strtoul (membuf, &p, 16);
|
|
|
if (val == 0 && membuf == p)
|
if (val == 0 && membuf == p)
|
monitor_error ("monitor_read_memory_single",
|
monitor_error ("monitor_read_memory_single",
|
"bad value from monitor",
|
"bad value from monitor",
|
memaddr, 0, membuf, 0);
|
memaddr, 0, membuf, 0);
|
|
|
/* supply register stores in target byte order, so swap here */
|
/* supply register stores in target byte order, so swap here */
|
|
|
store_unsigned_integer (myaddr, len, val);
|
store_unsigned_integer (myaddr, len, val);
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
|
/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
|
memory at MEMADDR. Returns length moved. Currently, we do no more
|
memory at MEMADDR. Returns length moved. Currently, we do no more
|
than 16 bytes at a time. */
|
than 16 bytes at a time. */
|
|
|
static int
|
static int
|
monitor_read_memory (memaddr, myaddr, len)
|
monitor_read_memory (memaddr, myaddr, len)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
{
|
{
|
unsigned int val;
|
unsigned int val;
|
char buf[512];
|
char buf[512];
|
char *p, *p1;
|
char *p, *p1;
|
int resp_len;
|
int resp_len;
|
int i;
|
int i;
|
CORE_ADDR dumpaddr;
|
CORE_ADDR dumpaddr;
|
|
|
if (len <= 0)
|
if (len <= 0)
|
{
|
{
|
monitor_debug ("Zero length call to monitor_read_memory\n");
|
monitor_debug ("Zero length call to monitor_read_memory\n");
|
return 0;
|
return 0;
|
}
|
}
|
|
|
monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
|
monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
|
paddr_nz (memaddr), (long) myaddr, len);
|
paddr_nz (memaddr), (long) myaddr, len);
|
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
memaddr = ADDR_BITS_REMOVE (memaddr);
|
memaddr = ADDR_BITS_REMOVE (memaddr);
|
|
|
if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
|
if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
|
return monitor_read_memory_single (memaddr, myaddr, len);
|
return monitor_read_memory_single (memaddr, myaddr, len);
|
|
|
len = min (len, 16);
|
len = min (len, 16);
|
|
|
/* Some dumpers align the first data with the preceeding 16
|
/* Some dumpers align the first data with the preceeding 16
|
byte boundary. Some print blanks and start at the
|
byte boundary. Some print blanks and start at the
|
requested boundary. EXACT_DUMPADDR
|
requested boundary. EXACT_DUMPADDR
|
*/
|
*/
|
|
|
dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
|
dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
|
? memaddr : memaddr & ~0x0f;
|
? memaddr : memaddr & ~0x0f;
|
|
|
/* 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)
|
if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
|
len = ((memaddr + len) & ~0xf) - memaddr;
|
len = ((memaddr + len) & ~0xf) - memaddr;
|
|
|
/* send the memory examine command */
|
/* send the memory examine command */
|
|
|
if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
|
if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
|
monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
|
monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
|
else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
|
else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
|
monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
|
monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
|
else
|
else
|
monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
|
monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
|
|
|
/* If TERM is present, we wait for that to show up. Also, (if TERM
|
/* 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
|
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
|
case, we collect all of the output into buf, and then wait for
|
the normal prompt. */
|
the normal prompt. */
|
|
|
if (current_monitor->getmem.term)
|
if (current_monitor->getmem.term)
|
{
|
{
|
resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
|
resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
|
|
|
if (resp_len <= 0)
|
if (resp_len <= 0)
|
monitor_error ("monitor_read_memory",
|
monitor_error ("monitor_read_memory",
|
"excessive response from monitor",
|
"excessive response from monitor",
|
memaddr, resp_len, buf, 0);
|
memaddr, resp_len, buf, 0);
|
|
|
if (current_monitor->getmem.term_cmd)
|
if (current_monitor->getmem.term_cmd)
|
{
|
{
|
SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
|
SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
|
strlen (current_monitor->getmem.term_cmd));
|
strlen (current_monitor->getmem.term_cmd));
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
}
|
}
|
else
|
else
|
resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
|
resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
|
|
|
p = buf;
|
p = buf;
|
|
|
/* If RESP_DELIM is specified, we search for that as a leading
|
/* If RESP_DELIM is specified, we search for that as a leading
|
delimiter for the values. Otherwise, we just start searching
|
delimiter for the values. Otherwise, we just start searching
|
from the start of the buf. */
|
from the start of the buf. */
|
|
|
if (current_monitor->getmem.resp_delim)
|
if (current_monitor->getmem.resp_delim)
|
{
|
{
|
int retval, tmp;
|
int retval, tmp;
|
struct re_registers resp_strings;
|
struct re_registers resp_strings;
|
monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
|
monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
|
|
|
memset (&resp_strings, 0, sizeof (struct re_registers));
|
memset (&resp_strings, 0, sizeof (struct re_registers));
|
tmp = strlen (p);
|
tmp = strlen (p);
|
retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
|
retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
|
&resp_strings);
|
&resp_strings);
|
|
|
if (retval < 0)
|
if (retval < 0)
|
monitor_error ("monitor_read_memory",
|
monitor_error ("monitor_read_memory",
|
"bad response from monitor",
|
"bad response from monitor",
|
memaddr, resp_len, buf, 0);
|
memaddr, resp_len, buf, 0);
|
|
|
p += resp_strings.end[0];
|
p += resp_strings.end[0];
|
#if 0
|
#if 0
|
p = strstr (p, current_monitor->getmem.resp_delim);
|
p = strstr (p, current_monitor->getmem.resp_delim);
|
if (!p)
|
if (!p)
|
monitor_error ("monitor_read_memory",
|
monitor_error ("monitor_read_memory",
|
"bad response from monitor",
|
"bad response from monitor",
|
memaddr, resp_len, buf, 0);
|
memaddr, resp_len, buf, 0);
|
p += strlen (current_monitor->getmem.resp_delim);
|
p += strlen (current_monitor->getmem.resp_delim);
|
#endif
|
#endif
|
}
|
}
|
monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
|
monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
|
if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
|
if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
|
{
|
{
|
char c;
|
char c;
|
int fetched = 0;
|
int fetched = 0;
|
i = len;
|
i = len;
|
c = *p;
|
c = *p;
|
|
|
|
|
while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
|
while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
|
{
|
{
|
if (isxdigit (c))
|
if (isxdigit (c))
|
{
|
{
|
if ((dumpaddr >= memaddr) && (i > 0))
|
if ((dumpaddr >= memaddr) && (i > 0))
|
{
|
{
|
val = fromhex (c) * 16 + fromhex (*(p + 1));
|
val = fromhex (c) * 16 + fromhex (*(p + 1));
|
*myaddr++ = val;
|
*myaddr++ = val;
|
if (monitor_debug_p || remote_debug)
|
if (monitor_debug_p || remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
|
fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
|
--i;
|
--i;
|
fetched++;
|
fetched++;
|
}
|
}
|
++dumpaddr;
|
++dumpaddr;
|
++p;
|
++p;
|
}
|
}
|
++p; /* skip a blank or other non hex char */
|
++p; /* skip a blank or other non hex char */
|
c = *p;
|
c = *p;
|
}
|
}
|
if (fetched == 0)
|
if (fetched == 0)
|
error ("Failed to read via monitor");
|
error ("Failed to read via monitor");
|
if (monitor_debug_p || remote_debug)
|
if (monitor_debug_p || remote_debug)
|
fprintf_unfiltered (gdb_stdlog, "\n");
|
fprintf_unfiltered (gdb_stdlog, "\n");
|
return fetched; /* Return the number of bytes actually read */
|
return fetched; /* Return the number of bytes actually read */
|
}
|
}
|
monitor_debug ("MON scanning bytes\n");
|
monitor_debug ("MON scanning bytes\n");
|
|
|
for (i = len; i > 0; i--)
|
for (i = len; i > 0; i--)
|
{
|
{
|
/* Skip non-hex chars, but bomb on end of string and newlines */
|
/* Skip non-hex chars, but bomb on end of string and newlines */
|
|
|
while (1)
|
while (1)
|
{
|
{
|
if (isxdigit (*p))
|
if (isxdigit (*p))
|
break;
|
break;
|
|
|
if (*p == '\000' || *p == '\n' || *p == '\r')
|
if (*p == '\000' || *p == '\n' || *p == '\r')
|
monitor_error ("monitor_read_memory",
|
monitor_error ("monitor_read_memory",
|
"badly terminated response from monitor",
|
"badly terminated response from monitor",
|
memaddr, resp_len, buf, 0);
|
memaddr, resp_len, buf, 0);
|
p++;
|
p++;
|
}
|
}
|
|
|
val = strtoul (p, &p1, 16);
|
val = strtoul (p, &p1, 16);
|
|
|
if (val == 0 && p == p1)
|
if (val == 0 && p == p1)
|
monitor_error ("monitor_read_memory",
|
monitor_error ("monitor_read_memory",
|
"bad value from monitor",
|
"bad value from monitor",
|
memaddr, resp_len, buf, 0);
|
memaddr, resp_len, buf, 0);
|
|
|
*myaddr++ = val;
|
*myaddr++ = val;
|
|
|
if (i == 1)
|
if (i == 1)
|
break;
|
break;
|
|
|
p = p1;
|
p = p1;
|
}
|
}
|
|
|
return len;
|
return len;
|
}
|
}
|
|
|
static int
|
static int
|
monitor_xfer_memory (memaddr, myaddr, len, write, target)
|
monitor_xfer_memory (memaddr, myaddr, len, write, target)
|
CORE_ADDR memaddr;
|
CORE_ADDR memaddr;
|
char *myaddr;
|
char *myaddr;
|
int len;
|
int len;
|
int write;
|
int write;
|
struct target_ops *target; /* ignored */
|
struct target_ops *target; /* ignored */
|
{
|
{
|
return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
|
return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
|
}
|
}
|
|
|
static void
|
static void
|
monitor_kill ()
|
monitor_kill ()
|
{
|
{
|
return; /* ignore attempts to kill target system */
|
return; /* ignore attempts to kill target system */
|
}
|
}
|
|
|
/* All we actually do is set the PC to the start address of exec_bfd, and start
|
/* All we actually do is set the PC to the start address of exec_bfd, and start
|
the program at that point. */
|
the program at that point. */
|
|
|
static void
|
static void
|
monitor_create_inferior (exec_file, args, env)
|
monitor_create_inferior (exec_file, args, env)
|
char *exec_file;
|
char *exec_file;
|
char *args;
|
char *args;
|
char **env;
|
char **env;
|
{
|
{
|
if (args && (*args != '\000'))
|
if (args && (*args != '\000'))
|
error ("Args are not supported by the monitor.");
|
error ("Args are not supported by the monitor.");
|
|
|
first_time = 1;
|
first_time = 1;
|
clear_proceed_status ();
|
clear_proceed_status ();
|
proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
|
proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
|
}
|
}
|
|
|
/* Clean up when a program exits.
|
/* Clean up when a program exits.
|
The program actually lives on in the remote processor's RAM, and may be
|
The program actually lives on in the remote processor's RAM, and may be
|
run again without a download. Don't leave it full of breakpoint
|
run again without a download. Don't leave it full of breakpoint
|
instructions. */
|
instructions. */
|
|
|
static void
|
static void
|
monitor_mourn_inferior ()
|
monitor_mourn_inferior ()
|
{
|
{
|
unpush_target (targ_ops);
|
unpush_target (targ_ops);
|
generic_mourn_inferior (); /* Do all the proper things now */
|
generic_mourn_inferior (); /* Do all the proper things now */
|
}
|
}
|
|
|
/* Tell the monitor to add a breakpoint. */
|
/* Tell the monitor to add a breakpoint. */
|
|
|
static int
|
static int
|
monitor_insert_breakpoint (addr, shadow)
|
monitor_insert_breakpoint (addr, shadow)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *shadow;
|
char *shadow;
|
{
|
{
|
int i;
|
int i;
|
unsigned char *bp;
|
unsigned char *bp;
|
int bplen;
|
int bplen;
|
|
|
monitor_debug ("MON inst bkpt %s\n", paddr (addr));
|
monitor_debug ("MON inst bkpt %s\n", paddr (addr));
|
if (current_monitor->set_break == NULL)
|
if (current_monitor->set_break == NULL)
|
error ("No set_break defined for this monitor");
|
error ("No set_break defined for this monitor");
|
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
addr = ADDR_BITS_REMOVE (addr);
|
addr = ADDR_BITS_REMOVE (addr);
|
|
|
/* Determine appropriate breakpoint size for this address. */
|
/* Determine appropriate breakpoint size for this address. */
|
bp = memory_breakpoint_from_pc (&addr, &bplen);
|
bp = memory_breakpoint_from_pc (&addr, &bplen);
|
|
|
for (i = 0; i < current_monitor->num_breakpoints; i++)
|
for (i = 0; i < current_monitor->num_breakpoints; i++)
|
{
|
{
|
if (breakaddr[i] == 0)
|
if (breakaddr[i] == 0)
|
{
|
{
|
breakaddr[i] = addr;
|
breakaddr[i] = addr;
|
monitor_read_memory (addr, shadow, bplen);
|
monitor_read_memory (addr, shadow, bplen);
|
monitor_printf (current_monitor->set_break, addr);
|
monitor_printf (current_monitor->set_break, addr);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
|
|
error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
|
error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
|
}
|
}
|
|
|
/* Tell the monitor to remove a breakpoint. */
|
/* Tell the monitor to remove a breakpoint. */
|
|
|
static int
|
static int
|
monitor_remove_breakpoint (addr, shadow)
|
monitor_remove_breakpoint (addr, shadow)
|
CORE_ADDR addr;
|
CORE_ADDR addr;
|
char *shadow;
|
char *shadow;
|
{
|
{
|
int i;
|
int i;
|
|
|
monitor_debug ("MON rmbkpt %s\n", paddr (addr));
|
monitor_debug ("MON rmbkpt %s\n", paddr (addr));
|
if (current_monitor->clr_break == NULL)
|
if (current_monitor->clr_break == NULL)
|
error ("No clr_break defined for this monitor");
|
error ("No clr_break defined for this monitor");
|
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
addr = ADDR_BITS_REMOVE (addr);
|
addr = ADDR_BITS_REMOVE (addr);
|
|
|
for (i = 0; i < current_monitor->num_breakpoints; i++)
|
for (i = 0; i < current_monitor->num_breakpoints; i++)
|
{
|
{
|
if (breakaddr[i] == addr)
|
if (breakaddr[i] == addr)
|
{
|
{
|
breakaddr[i] = 0;
|
breakaddr[i] = 0;
|
/* some monitors remove breakpoints based on the address */
|
/* some monitors remove breakpoints based on the address */
|
if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
|
if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
|
monitor_printf (current_monitor->clr_break, addr);
|
monitor_printf (current_monitor->clr_break, addr);
|
else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
|
else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
|
monitor_printf (current_monitor->clr_break, i + 1);
|
monitor_printf (current_monitor->clr_break, i + 1);
|
else
|
else
|
monitor_printf (current_monitor->clr_break, i);
|
monitor_printf (current_monitor->clr_break, i);
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
return 0;
|
return 0;
|
}
|
}
|
}
|
}
|
fprintf_unfiltered (gdb_stderr,
|
fprintf_unfiltered (gdb_stderr,
|
"Can't find breakpoint associated with 0x%s\n",
|
"Can't find breakpoint associated with 0x%s\n",
|
paddr_nz (addr));
|
paddr_nz (addr));
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
|
/* 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. */
|
an S-record. Return non-zero if the ACK is received properly. */
|
|
|
static int
|
static int
|
monitor_wait_srec_ack ()
|
monitor_wait_srec_ack ()
|
{
|
{
|
int ch;
|
int ch;
|
|
|
if (current_monitor->flags & MO_SREC_ACK_PLUS)
|
if (current_monitor->flags & MO_SREC_ACK_PLUS)
|
{
|
{
|
return (readchar (timeout) == '+');
|
return (readchar (timeout) == '+');
|
}
|
}
|
else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
|
else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
|
{
|
{
|
/* Eat two backspaces, a "rotating" char (|/-\), and a space. */
|
/* Eat two backspaces, a "rotating" char (|/-\), and a space. */
|
if ((ch = readchar (1)) < 0)
|
if ((ch = readchar (1)) < 0)
|
return 0;
|
return 0;
|
if ((ch = readchar (1)) < 0)
|
if ((ch = readchar (1)) < 0)
|
return 0;
|
return 0;
|
if ((ch = readchar (1)) < 0)
|
if ((ch = readchar (1)) < 0)
|
return 0;
|
return 0;
|
if ((ch = readchar (1)) < 0)
|
if ((ch = readchar (1)) < 0)
|
return 0;
|
return 0;
|
}
|
}
|
return 1;
|
return 1;
|
}
|
}
|
|
|
/* monitor_load -- download a file. */
|
/* monitor_load -- download a file. */
|
|
|
static void
|
static void
|
monitor_load (file, from_tty)
|
monitor_load (file, from_tty)
|
char *file;
|
char *file;
|
int from_tty;
|
int from_tty;
|
{
|
{
|
dcache_flush (remote_dcache);
|
dcache_flush (remote_dcache);
|
monitor_debug ("MON load\n");
|
monitor_debug ("MON load\n");
|
|
|
if (current_monitor->load_routine)
|
if (current_monitor->load_routine)
|
current_monitor->load_routine (monitor_desc, file, hashmark);
|
current_monitor->load_routine (monitor_desc, file, hashmark);
|
else
|
else
|
{ /* The default is ascii S-records */
|
{ /* The default is ascii S-records */
|
int n;
|
int n;
|
unsigned long load_offset;
|
unsigned long load_offset;
|
char buf[128];
|
char buf[128];
|
|
|
/* enable user to specify address for downloading as 2nd arg to load */
|
/* enable user to specify address for downloading as 2nd arg to load */
|
n = sscanf (file, "%s 0x%lx", buf, &load_offset);
|
n = sscanf (file, "%s 0x%lx", buf, &load_offset);
|
if (n > 1)
|
if (n > 1)
|
file = buf;
|
file = buf;
|
else
|
else
|
load_offset = 0;
|
load_offset = 0;
|
|
|
monitor_printf (current_monitor->load);
|
monitor_printf (current_monitor->load);
|
if (current_monitor->loadresp)
|
if (current_monitor->loadresp)
|
monitor_expect (current_monitor->loadresp, NULL, 0);
|
monitor_expect (current_monitor->loadresp, NULL, 0);
|
|
|
load_srec (monitor_desc, file, (bfd_vma) load_offset,
|
load_srec (monitor_desc, file, (bfd_vma) load_offset,
|
32, SREC_ALL, hashmark,
|
32, SREC_ALL, hashmark,
|
current_monitor->flags & MO_SREC_ACK ?
|
current_monitor->flags & MO_SREC_ACK ?
|
monitor_wait_srec_ack : NULL);
|
monitor_wait_srec_ack : NULL);
|
|
|
monitor_expect_prompt (NULL, 0);
|
monitor_expect_prompt (NULL, 0);
|
}
|
}
|
|
|
/* Finally, make the PC point at the start address */
|
/* Finally, make the PC point at the start address */
|
|
|
if (exec_bfd)
|
if (exec_bfd)
|
write_pc (bfd_get_start_address (exec_bfd));
|
write_pc (bfd_get_start_address (exec_bfd));
|
|
|
inferior_pid = 0; /* No process now */
|
inferior_pid = 0; /* No process now */
|
|
|
/* This is necessary because many things were based on the PC at the time that
|
/* 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
|
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
|
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
|
normal_stop, except that the stack may not be valid, and things would get
|
horribly confused... */
|
horribly confused... */
|
|
|
clear_symtab_users ();
|
clear_symtab_users ();
|
}
|
}
|
|
|
static void
|
static void
|
monitor_stop ()
|
monitor_stop ()
|
{
|
{
|
monitor_debug ("MON stop\n");
|
monitor_debug ("MON stop\n");
|
if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
|
if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
|
SERIAL_SEND_BREAK (monitor_desc);
|
SERIAL_SEND_BREAK (monitor_desc);
|
if (current_monitor->stop)
|
if (current_monitor->stop)
|
monitor_printf_noecho (current_monitor->stop);
|
monitor_printf_noecho (current_monitor->stop);
|
}
|
}
|
|
|
/* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
|
/* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
|
in OUTPUT until the prompt is seen. FIXME: We read the characters
|
in OUTPUT until the prompt is seen. FIXME: We read the characters
|
ourseleves here cause of a nasty echo. */
|
ourseleves here cause of a nasty echo. */
|
|
|
static void
|
static void
|
monitor_rcmd (char *command,
|
monitor_rcmd (char *command,
|
struct ui_file *outbuf)
|
struct ui_file *outbuf)
|
{
|
{
|
char *p;
|
char *p;
|
int resp_len;
|
int resp_len;
|
char buf[1000];
|
char buf[1000];
|
|
|
if (monitor_desc == NULL)
|
if (monitor_desc == NULL)
|
error ("monitor target not open.");
|
error ("monitor target not open.");
|
|
|
p = current_monitor->prompt;
|
p = current_monitor->prompt;
|
|
|
/* Send the command. Note that if no args were supplied, then we're
|
/* Send the command. Note that if no args were supplied, then we're
|
just sending the monitor a newline, which is sometimes useful. */
|
just sending the monitor a newline, which is sometimes useful. */
|
|
|
monitor_printf ("%s\r", (command ? command : ""));
|
monitor_printf ("%s\r", (command ? command : ""));
|
|
|
resp_len = monitor_expect_prompt (buf, sizeof buf);
|
resp_len = monitor_expect_prompt (buf, sizeof buf);
|
|
|
fputs_unfiltered (buf, outbuf); /* Output the response */
|
fputs_unfiltered (buf, outbuf); /* Output the response */
|
}
|
}
|
|
|
/* Convert hex digit A to a number. */
|
/* Convert hex digit A to a number. */
|
|
|
#if 0
|
#if 0
|
static int
|
static int
|
from_hex (a)
|
from_hex (a)
|
int a;
|
int a;
|
{
|
{
|
if (a >= '0' && a <= '9')
|
if (a >= '0' && a <= '9')
|
return a - '0';
|
return a - '0';
|
if (a >= 'a' && a <= 'f')
|
if (a >= 'a' && a <= 'f')
|
return a - 'a' + 10;
|
return a - 'a' + 10;
|
if (a >= 'A' && a <= 'F')
|
if (a >= 'A' && a <= 'F')
|
return a - 'A' + 10;
|
return a - 'A' + 10;
|
|
|
error ("Reply contains invalid hex digit 0x%x", a);
|
error ("Reply contains invalid hex digit 0x%x", a);
|
}
|
}
|
#endif
|
#endif
|
|
|
char *
|
char *
|
monitor_get_dev_name ()
|
monitor_get_dev_name ()
|
{
|
{
|
return dev_name;
|
return dev_name;
|
}
|
}
|
|
|
static struct target_ops monitor_ops;
|
static struct target_ops monitor_ops;
|
|
|
static void
|
static void
|
init_base_monitor_ops (void)
|
init_base_monitor_ops (void)
|
{
|
{
|
monitor_ops.to_shortname = NULL;
|
monitor_ops.to_shortname = NULL;
|
monitor_ops.to_longname = NULL;
|
monitor_ops.to_longname = NULL;
|
monitor_ops.to_doc = NULL;
|
monitor_ops.to_doc = NULL;
|
monitor_ops.to_open = NULL;
|
monitor_ops.to_open = NULL;
|
monitor_ops.to_close = monitor_close;
|
monitor_ops.to_close = monitor_close;
|
monitor_ops.to_attach = NULL;
|
monitor_ops.to_attach = NULL;
|
monitor_ops.to_post_attach = NULL;
|
monitor_ops.to_post_attach = NULL;
|
monitor_ops.to_require_attach = NULL;
|
monitor_ops.to_require_attach = NULL;
|
monitor_ops.to_detach = monitor_detach;
|
monitor_ops.to_detach = monitor_detach;
|
monitor_ops.to_require_detach = NULL;
|
monitor_ops.to_require_detach = NULL;
|
monitor_ops.to_resume = monitor_resume;
|
monitor_ops.to_resume = monitor_resume;
|
monitor_ops.to_wait = monitor_wait;
|
monitor_ops.to_wait = monitor_wait;
|
monitor_ops.to_post_wait = NULL;
|
monitor_ops.to_post_wait = NULL;
|
monitor_ops.to_fetch_registers = monitor_fetch_registers;
|
monitor_ops.to_fetch_registers = monitor_fetch_registers;
|
monitor_ops.to_store_registers = monitor_store_registers;
|
monitor_ops.to_store_registers = monitor_store_registers;
|
monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
|
monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
|
monitor_ops.to_xfer_memory = monitor_xfer_memory;
|
monitor_ops.to_xfer_memory = monitor_xfer_memory;
|
monitor_ops.to_files_info = monitor_files_info;
|
monitor_ops.to_files_info = monitor_files_info;
|
monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
|
monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
|
monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
|
monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
|
monitor_ops.to_terminal_init = 0;
|
monitor_ops.to_terminal_init = 0;
|
monitor_ops.to_terminal_inferior = 0;
|
monitor_ops.to_terminal_inferior = 0;
|
monitor_ops.to_terminal_ours_for_output = 0;
|
monitor_ops.to_terminal_ours_for_output = 0;
|
monitor_ops.to_terminal_ours = 0;
|
monitor_ops.to_terminal_ours = 0;
|
monitor_ops.to_terminal_info = 0;
|
monitor_ops.to_terminal_info = 0;
|
monitor_ops.to_kill = monitor_kill;
|
monitor_ops.to_kill = monitor_kill;
|
monitor_ops.to_load = monitor_load;
|
monitor_ops.to_load = monitor_load;
|
monitor_ops.to_lookup_symbol = 0;
|
monitor_ops.to_lookup_symbol = 0;
|
monitor_ops.to_create_inferior = monitor_create_inferior;
|
monitor_ops.to_create_inferior = monitor_create_inferior;
|
monitor_ops.to_post_startup_inferior = NULL;
|
monitor_ops.to_post_startup_inferior = NULL;
|
monitor_ops.to_acknowledge_created_inferior = NULL;
|
monitor_ops.to_acknowledge_created_inferior = NULL;
|
monitor_ops.to_clone_and_follow_inferior = NULL;
|
monitor_ops.to_clone_and_follow_inferior = NULL;
|
monitor_ops.to_post_follow_inferior_by_clone = NULL;
|
monitor_ops.to_post_follow_inferior_by_clone = NULL;
|
monitor_ops.to_insert_fork_catchpoint = NULL;
|
monitor_ops.to_insert_fork_catchpoint = NULL;
|
monitor_ops.to_remove_fork_catchpoint = NULL;
|
monitor_ops.to_remove_fork_catchpoint = NULL;
|
monitor_ops.to_insert_vfork_catchpoint = NULL;
|
monitor_ops.to_insert_vfork_catchpoint = NULL;
|
monitor_ops.to_remove_vfork_catchpoint = NULL;
|
monitor_ops.to_remove_vfork_catchpoint = NULL;
|
monitor_ops.to_has_forked = NULL;
|
monitor_ops.to_has_forked = NULL;
|
monitor_ops.to_has_vforked = NULL;
|
monitor_ops.to_has_vforked = NULL;
|
monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
|
monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
|
monitor_ops.to_post_follow_vfork = NULL;
|
monitor_ops.to_post_follow_vfork = NULL;
|
monitor_ops.to_insert_exec_catchpoint = NULL;
|
monitor_ops.to_insert_exec_catchpoint = NULL;
|
monitor_ops.to_remove_exec_catchpoint = NULL;
|
monitor_ops.to_remove_exec_catchpoint = NULL;
|
monitor_ops.to_has_execd = NULL;
|
monitor_ops.to_has_execd = NULL;
|
monitor_ops.to_reported_exec_events_per_exec_call = NULL;
|
monitor_ops.to_reported_exec_events_per_exec_call = NULL;
|
monitor_ops.to_has_exited = NULL;
|
monitor_ops.to_has_exited = NULL;
|
monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
|
monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
|
monitor_ops.to_can_run = 0;
|
monitor_ops.to_can_run = 0;
|
monitor_ops.to_notice_signals = 0;
|
monitor_ops.to_notice_signals = 0;
|
monitor_ops.to_thread_alive = 0;
|
monitor_ops.to_thread_alive = 0;
|
monitor_ops.to_stop = monitor_stop;
|
monitor_ops.to_stop = monitor_stop;
|
monitor_ops.to_rcmd = monitor_rcmd;
|
monitor_ops.to_rcmd = monitor_rcmd;
|
monitor_ops.to_pid_to_exec_file = NULL;
|
monitor_ops.to_pid_to_exec_file = NULL;
|
monitor_ops.to_core_file_to_sym_file = NULL;
|
monitor_ops.to_core_file_to_sym_file = NULL;
|
monitor_ops.to_stratum = process_stratum;
|
monitor_ops.to_stratum = process_stratum;
|
monitor_ops.DONT_USE = 0;
|
monitor_ops.DONT_USE = 0;
|
monitor_ops.to_has_all_memory = 1;
|
monitor_ops.to_has_all_memory = 1;
|
monitor_ops.to_has_memory = 1;
|
monitor_ops.to_has_memory = 1;
|
monitor_ops.to_has_stack = 1;
|
monitor_ops.to_has_stack = 1;
|
monitor_ops.to_has_registers = 1;
|
monitor_ops.to_has_registers = 1;
|
monitor_ops.to_has_execution = 1;
|
monitor_ops.to_has_execution = 1;
|
monitor_ops.to_sections = 0;
|
monitor_ops.to_sections = 0;
|
monitor_ops.to_sections_end = 0;
|
monitor_ops.to_sections_end = 0;
|
monitor_ops.to_magic = OPS_MAGIC;
|
monitor_ops.to_magic = OPS_MAGIC;
|
} /* init_base_monitor_ops */
|
} /* init_base_monitor_ops */
|
|
|
/* Init the target_ops structure pointed at by OPS */
|
/* Init the target_ops structure pointed at by OPS */
|
|
|
void
|
void
|
init_monitor_ops (ops)
|
init_monitor_ops (ops)
|
struct target_ops *ops;
|
struct target_ops *ops;
|
{
|
{
|
if (monitor_ops.to_magic != OPS_MAGIC)
|
if (monitor_ops.to_magic != OPS_MAGIC)
|
init_base_monitor_ops ();
|
init_base_monitor_ops ();
|
|
|
memcpy (ops, &monitor_ops, sizeof monitor_ops);
|
memcpy (ops, &monitor_ops, sizeof monitor_ops);
|
}
|
}
|
|
|
/* Define additional commands that are usually only used by monitors. */
|
/* Define additional commands that are usually only used by monitors. */
|
|
|
void
|
void
|
_initialize_remote_monitors ()
|
_initialize_remote_monitors ()
|
{
|
{
|
init_base_monitor_ops ();
|
init_base_monitor_ops ();
|
add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
|
add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
|
(char *) &hashmark,
|
(char *) &hashmark,
|
"Set display of activity while downloading a file.\n\
|
"Set display of activity while downloading a file.\n\
|
When enabled, a hashmark \'#\' is displayed.",
|
When enabled, a hashmark \'#\' is displayed.",
|
&setlist),
|
&setlist),
|
&showlist);
|
&showlist);
|
|
|
add_show_from_set
|
add_show_from_set
|
(add_set_cmd ("monitor", no_class, var_zinteger,
|
(add_set_cmd ("monitor", no_class, var_zinteger,
|
(char *) &monitor_debug_p,
|
(char *) &monitor_debug_p,
|
"Set debugging of remote monitor communication.\n\
|
"Set debugging of remote monitor communication.\n\
|
When enabled, communication between GDB and the remote monitor\n\
|
When enabled, communication between GDB and the remote monitor\n\
|
is displayed.", &setdebuglist),
|
is displayed.", &setdebuglist),
|
&showdebuglist);
|
&showdebuglist);
|
}
|
}
|
|
|
