/* Remote target communications for serial-line targets in custom GDB protocol
- Copyright 1988, 1991, 1992 Free Software Foundation, Inc.
+ Copyright 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
This file is part of GDB.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
-Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* Remote communication protocol.
- All values are encoded in ascii hex digits.
+
+ A debug packet whose contents are <data>
+ is encapsulated for transmission in the form:
+
+ $ <data> # CSUM1 CSUM2
+
+ <data> must be ASCII alphanumeric and cannot include characters
+ '$' or '#'. If <data> starts with two characters followed by
+ ':', then the existing stubs interpret this as a sequence number.
+
+ CSUM1 and CSUM2 are ascii hex representation of an 8-bit
+ checksum of <data>, the most significant nibble is sent first.
+ the hex digits 0-9,a-f are used.
+
+ Receiver responds with:
+
+ + - if CSUM is correct and ready for next packet
+ - - if CSUM is incorrect
+
+ <data> is as follows:
+ Most values are encoded in ascii hex digits. Signal numbers are according
+ to the numbering in target.h.
Request Packet
+ set thread Hct... Set thread for subsequent operations.
+ c = 'c' for thread used in step and
+ continue; t... can be -1 for all
+ threads.
+ c = 'g' for thread used in other
+ operations. If zero, pick a thread,
+ any thread.
+ reply OK for success
+ ENN for an error.
+
read registers g
reply XX....X Each byte of register data
is described by two hex digits.
reply OK for success
ENN for an error
+ write reg Pn...=r... Write register n... with value r...,
+ which contains two hex digits for each
+ byte in the register (target byte
+ order).
+ reply OK for success
+ ENN for an error
+ (not supported by all stubs).
+
read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
reply XX..XX XX..XX is mem contents
+ Can be fewer bytes than requested
+ if able to read only part of the data.
or ENN NN is errno
write mem MAA..AA,LLLL:XX..XX
LLLL is number of bytes,
XX..XX is data
reply OK for success
- ENN for an error
+ ENN for an error (this includes the case
+ where only part of the data was
+ written).
- cont cAA..AA AA..AA is address to resume
+ continue cAA..AA AA..AA is address to resume
If AA..AA is omitted,
resume at same address.
If AA..AA is omitted,
resume at same address.
+ continue with Csig;AA..AA Continue with signal sig (hex signal
+ signal number). If ;AA..AA is omitted, resume
+ at same address.
+
+ step with Ssig;AA..AA Like 'C' but step not continue.
+ signal
+
last signal ? Reply the current reason for stopping.
This is the same reply as is generated
for step or cont : SAA where AA is the
signal number.
+ detach D Reply OK.
+
There is no immediate reply to step or cont.
The reply comes when the machine stops.
- It is SAA AA is the "signal number"
-
- or... TAAPPPPPPPPFFFFFFFF
- where AA is the signal number,
- PPPPPPPP is the PC (PC_REGNUM), and
- FFFFFFFF is the frame ptr (FP_REGNUM).
-
- kill req k
-*/
+ It is SAA AA is the signal number.
+
+ or... TAAn...:r...;n...:r...;n...:r...;
+ AA = signal number
+ n... = register number (hex)
+ r... = register contents
+ n... = `thread'
+ r... = thread process ID. This is
+ a hex integer.
+ n... = other string not starting
+ with valid hex digit.
+ gdb should ignore this n,r pair
+ and go on to the next. This way
+ we can extend the protocol.
+ or... WAA The process exited, and AA is
+ the exit status. This is only
+ applicable for certains sorts of
+ targets.
+ or... XAA The process terminated with signal
+ AA.
+ or... OXX..XX XX..XX is hex encoding of ASCII data. This
+ can happen at any time while the program is
+ running and the debugger should
+ continue to wait for 'W', 'T', etc.
+
+ thread alive TXX Find out if the thread XX is alive.
+ reply OK thread is still alive
+ ENN thread is dead
+
+ remote restart RXX Restart the remote server
+
+ extended ops ! Use the extended remote protocol.
+ Sticky -- only needs to be set once.
+
+ kill request k
+
+ toggle debug d toggle debug flag (see 386 & 68k stubs)
+ reset r reset -- see sparc stub.
+ reserved <other> On other requests, the stub should
+ ignore the request and send an empty
+ response ($#<checksum>). This way
+ we can extend the protocol and GDB
+ can tell whether the stub it is
+ talking to uses the old or the new.
+ search tAA:PP,MM Search backwards starting at address
+ AA for a match with pattern PP and
+ mask MM. PP and MM are 4 bytes.
+ Not supported by all stubs.
+
+ general query qXXXX Request info about XXXX.
+ general set QXXXX=yyyy Set value of XXXX to yyyy.
+ query sect offs qOffsets Get section offsets. Reply is
+ Text=xxx;Data=yyy;Bss=zzz
+
+ Responses can be run-length encoded to save space. A '*' means that
+ the next character is an ASCII encoding giving a repeat count which
+ stands for that many repititions of the character preceding the '*'.
+ The encoding is n+29, yielding a printable character where n >=3
+ (which is where rle starts to win). Don't use an n > 126.
+
+ So
+ "0* " means the same as "0000". */
#include "defs.h"
-#include <string.h>
+#include "gdb_string.h"
#include <fcntl.h>
#include "frame.h"
#include "inferior.h"
+#include "bfd.h"
+#include "symfile.h"
#include "target.h"
#include "wait.h"
-#include "terminal.h"
+/*#include "terminal.h"*/
#include "gdbcmd.h"
+#include "objfiles.h"
+#include "gdb-stabs.h"
+#include "gdbthread.h"
+
+#include "dcache.h"
-#if !defined(DONT_USE_REMOTE)
#ifdef USG
#include <sys/types.h>
#endif
#include <signal.h>
+#include "serial.h"
/* Prototypes for local functions */
-static void
-remote_write_bytes PARAMS ((CORE_ADDR, char *, int));
+static int remote_write_bytes PARAMS ((CORE_ADDR memaddr,
+ char *myaddr, int len));
-static void
-remote_read_bytes PARAMS ((CORE_ADDR, char *, int));
+static int remote_read_bytes PARAMS ((CORE_ADDR memaddr,
+ char *myaddr, int len));
-static void
-remote_files_info PARAMS ((struct target_ops *));
+static void remote_files_info PARAMS ((struct target_ops *ignore));
-static int
-remote_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+static int remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
+ int len, int should_write,
+ struct target_ops *target));
-static void
-remote_prepare_to_store PARAMS ((void));
+static void remote_prepare_to_store PARAMS ((void));
-static void
-remote_fetch_registers PARAMS ((int));
+static void remote_fetch_registers PARAMS ((int regno));
-static void
-remote_resume PARAMS ((int, int));
+static void remote_resume PARAMS ((int pid, int step,
+ enum target_signal siggnal));
-static void
-remote_open PARAMS ((char *, int));
+static int remote_start_remote PARAMS ((char *dummy));
-static void
-remote_close PARAMS ((int));
+static void remote_open PARAMS ((char *name, int from_tty));
-static void
-remote_store_registers PARAMS ((int));
+static void extended_remote_open PARAMS ((char *name, int from_tty));
-static void
-getpkt PARAMS ((char *));
+static void remote_open_1 PARAMS ((char *, int, struct target_ops *));
-static void
-putpkt PARAMS ((char *));
+static void remote_close PARAMS ((int quitting));
-static void
-remote_send PARAMS ((char *));
+static void remote_store_registers PARAMS ((int regno));
-static int
-readchar PARAMS ((void));
+static void remote_mourn PARAMS ((void));
-static int
-remote_wait PARAMS ((WAITTYPE *));
+static void extended_remote_restart PARAMS ((void));
-static int
-tohex PARAMS ((int));
+static void extended_remote_mourn PARAMS ((void));
-static int
-fromhex PARAMS ((int));
+static void extended_remote_create_inferior PARAMS ((char *, char *, char **));
-static void
-remote_detach PARAMS ((char *, int));
+static void remote_mourn_1 PARAMS ((struct target_ops *));
+static void getpkt PARAMS ((char *buf, int forever));
-extern struct target_ops remote_ops; /* Forward decl */
+static int putpkt PARAMS ((char *buf));
-static int kiodebug = 0;
-static int timeout = 5;
+static void remote_send PARAMS ((char *buf));
-#if 0
-int icache;
-#endif
+static int readchar PARAMS ((int timeout));
+
+static int remote_wait PARAMS ((int pid, struct target_waitstatus *status));
+
+static void remote_kill PARAMS ((void));
+
+static int tohex PARAMS ((int nib));
+
+static int fromhex PARAMS ((int a));
+
+static void remote_detach PARAMS ((char *args, int from_tty));
+
+static void remote_interrupt PARAMS ((int signo));
+
+static void remote_interrupt_twice PARAMS ((int signo));
+
+static void interrupt_query PARAMS ((void));
+
+static void set_thread PARAMS ((int, int));
+
+static int remote_thread_alive PARAMS ((int));
+
+static void get_offsets PARAMS ((void));
+
+static int read_frame PARAMS ((char *));
+
+static int remote_insert_breakpoint PARAMS ((CORE_ADDR, char *));
+
+static int remote_remove_breakpoint PARAMS ((CORE_ADDR, char *));
+
+static struct target_ops remote_ops; /* Forward decl */
+static struct target_ops extended_remote_ops; /* Forward decl */
+
+/* This was 5 seconds, which is a long time to sit and wait.
+ Unless this is going though some terminal server or multiplexer or
+ other form of hairy serial connection, I would think 2 seconds would
+ be plenty. */
+
+/* Changed to allow option to set timeout value.
+ was static int remote_timeout = 2; */
+extern int remote_timeout;
-/* Descriptor for I/O to remote machine. Initialize it to -1 so that
+/* This variable chooses whether to send a ^C or a break when the user
+ requests program interruption. Although ^C is usually what remote
+ systems expect, and that is the default here, sometimes a break is
+ preferable instead. */
+
+static int remote_break;
+
+/* Descriptor for I/O to remote machine. Initialize it to NULL so that
remote_open knows that we don't have a file open when the program
starts. */
-int remote_desc = -1;
+static serial_t remote_desc = NULL;
-#define PBUFSIZ 1024
+/* Having this larger than 400 causes us to be incompatible with m68k-stub.c
+ and i386-stub.c. Normally, no one would notice because it only matters
+ for writing large chunks of memory (e.g. in downloads). Also, this needs
+ to be more than 400 if required to hold the registers (see below, where
+ we round it up based on REGISTER_BYTES). */
+#define PBUFSIZ 400
/* Maximum number of bytes to read/write at once. The value here
is chosen to fill up a packet (the headers account for the 32). */
#define MAXBUFBYTES ((PBUFSIZ-32)/2)
/* Round up PBUFSIZ to hold all the registers, at least. */
+/* The blank line after the #if seems to be required to work around a
+ bug in HP's PA compiler. */
#if REGISTER_BYTES > MAXBUFBYTES
-#undef PBUFSIZ
+
+#undef PBUFSIZ
#define PBUFSIZ (REGISTER_BYTES * 2 + 32)
#endif
+
+/* This variable sets the number of bytes to be written to the target
+ in a single packet. Normally PBUFSIZ is satisfactory, but some
+ targets need smaller values (perhaps because the receiving end
+ is slow). */
+
+static int remote_write_size = PBUFSIZ;
+
+/* This is the size (in chars) of the first response to the `g' command. This
+ is used to limit the size of the memory read and write commands to prevent
+ stub buffers from overflowing. */
+
+static int remote_register_buf_size = 0;
+
+/* Should we try the 'P' request? If this is set to one when the stub
+ doesn't support 'P', the only consequence is some unnecessary traffic. */
+static int stub_supports_P = 1;
+
+/* These are pointers to hook functions that may be set in order to
+ modify resume/wait behavior for a particular architecture. */
+
+void (*target_resume_hook) PARAMS ((void));
+void (*target_wait_loop_hook) PARAMS ((void));
+
\f
-/* Called when SIGALRM signal sent due to alarm() timeout. */
-#ifndef HAVE_TERMIO
-void
-remote_timer (signo)
- int signo;
+/* These are the threads which we last sent to the remote system. -1 for all
+ or -2 for not sent yet. */
+int general_thread;
+int cont_thread;
+
+static void
+set_thread (th, gen)
+ int th;
+ int gen;
+{
+ char buf[PBUFSIZ];
+ int state = gen ? general_thread : cont_thread;
+ if (state == th)
+ return;
+ buf[0] = 'H';
+ buf[1] = gen ? 'g' : 'c';
+ if (th == 42000)
+ {
+ buf[2] = '0';
+ buf[3] = '\0';
+ }
+ else if (th < 0)
+ sprintf (&buf[2], "-%x", -th);
+ else
+ sprintf (&buf[2], "%x", th);
+ putpkt (buf);
+ getpkt (buf, 0);
+ if (gen)
+ general_thread = th;
+ else
+ cont_thread = th;
+}
+\f
+/* Return nonzero if the thread TH is still alive on the remote system. */
+
+static int
+remote_thread_alive (th)
+ int th;
{
- if (kiodebug)
- printf ("remote_timer called\n");
+ char buf[PBUFSIZ];
- alarm (timeout);
+ buf[0] = 'T';
+ if (th < 0)
+ sprintf (&buf[1], "-%x", -th);
+ else
+ sprintf (&buf[1], "%x", th);
+ putpkt (buf);
+ getpkt (buf, 0);
+ return (buf[0] == 'O' && buf[1] == 'K');
}
-#endif
+/* Restart the remote side; this is an extended protocol operation. */
+
+static void
+extended_remote_restart ()
+{
+ char buf[PBUFSIZ];
+
+ /* Send the restart command; for reasons I don't understand the
+ remote side really expects a number after the "R". */
+ buf[0] = 'R';
+ sprintf (&buf[1], "%x", 0);
+ putpkt (buf);
+
+ /* Now query for status so this looks just like we restarted
+ gdbserver from scratch. */
+ putpkt ("?");
+ getpkt (buf, 0);
+}
+\f
/* Clean up connection to a remote debugger. */
/* ARGSUSED */
remote_close (quitting)
int quitting;
{
- if (remote_desc >= 0)
- close (remote_desc);
- remote_desc = -1;
+ if (remote_desc)
+ SERIAL_CLOSE (remote_desc);
+ remote_desc = NULL;
}
-/* Translate baud rates from integers to damn B_codes. Unix should
- have outgrown this crap years ago, but even POSIX wouldn't buck it. */
+/* Query the remote side for the text, data and bss offsets. */
-#ifndef B19200
-#define B19200 EXTA
-#endif
-#ifndef B38400
-#define B38400 EXTB
-#endif
+static void
+get_offsets ()
+{
+ char buf[PBUFSIZ];
+ int nvals;
+ CORE_ADDR text_addr, data_addr, bss_addr;
+ struct section_offsets *offs;
+ putpkt ("qOffsets");
+ getpkt (buf, 0);
-static struct {int rate, damn_b;} baudtab[] = {
- {0, B0},
- {50, B50},
- {75, B75},
- {110, B110},
- {134, B134},
- {150, B150},
- {200, B200},
- {300, B300},
- {600, B600},
- {1200, B1200},
- {1800, B1800},
- {2400, B2400},
- {4800, B4800},
- {9600, B9600},
- {19200, B19200},
- {38400, B38400},
- {-1, -1},
-};
+ if (buf[0] == '\000')
+ return; /* Return silently. Stub doesn't support this
+ command. */
+ if (buf[0] == 'E')
+ {
+ warning ("Remote failure reply: %s", buf);
+ return;
+ }
+
+ nvals = sscanf (buf, "Text=%lx;Data=%lx;Bss=%lx", &text_addr, &data_addr,
+ &bss_addr);
+ if (nvals != 3)
+ error ("Malformed response to offset query, %s", buf);
+
+ if (symfile_objfile == NULL)
+ return;
+
+ offs = (struct section_offsets *) alloca (sizeof (struct section_offsets)
+ + symfile_objfile->num_sections
+ * sizeof (offs->offsets));
+ memcpy (offs, symfile_objfile->section_offsets,
+ sizeof (struct section_offsets)
+ + symfile_objfile->num_sections
+ * sizeof (offs->offsets));
+
+ ANOFFSET (offs, SECT_OFF_TEXT) = text_addr;
+
+ /* This is a temporary kludge to force data and bss to use the same offsets
+ because that's what nlmconv does now. The real solution requires changes
+ to the stub and remote.c that I don't have time to do right now. */
+
+ ANOFFSET (offs, SECT_OFF_DATA) = data_addr;
+ ANOFFSET (offs, SECT_OFF_BSS) = data_addr;
+
+ objfile_relocate (symfile_objfile, offs);
+}
+
+/* Stub for catch_errors. */
static int
-damn_b (rate)
- int rate;
+remote_start_remote (dummy)
+ char *dummy;
{
- int i;
+ immediate_quit = 1; /* Allow user to interrupt it */
+
+ /* Ack any packet which the remote side has already sent. */
+ SERIAL_WRITE (remote_desc, "+", 1);
+
+ /* Let the stub know that we want it to return the thread. */
+ set_thread (-1, 0);
+
+ get_offsets (); /* Get text, data & bss offsets */
+
+ putpkt ("?"); /* initiate a query from remote machine */
+ immediate_quit = 0;
- for (i = 0; baudtab[i].rate != -1; i++)
- if (rate == baudtab[i].rate) return baudtab[i].damn_b;
- return B38400; /* Random */
+ start_remote (); /* Initialize gdb process mechanisms */
+ return 1;
}
/* Open a connection to a remote debugger.
char *name;
int from_tty;
{
- TERMINAL sg;
- int a_rate, b_rate = 0;
- int baudrate_set = 0;
+ remote_open_1 (name, from_tty, &remote_ops);
+}
+
+/* Open a connection to a remote debugger using the extended
+ remote gdb protocol. NAME is the filename used for communication. */
+
+static void
+extended_remote_open (name, from_tty)
+ char *name;
+ int from_tty;
+{
+ char buf[PBUFSIZ];
+
+ /* Do the basic remote open stuff. */
+ remote_open_1 (name, from_tty, &extended_remote_ops);
+
+ /* Now tell the remote that we're using the extended protocol. */
+ putpkt ("!");
+ getpkt (buf, 0);
+
+}
+
+/* Generic code for opening a connection to a remote target. */
+static DCACHE *remote_dcache;
+static void
+remote_open_1 (name, from_tty, target)
+ char *name;
+ int from_tty;
+ struct target_ops *target;
+{
if (name == 0)
- error (
-"To open a remote debug connection, you need to specify what serial\n\
+ error ("To open a remote debug connection, you need to specify what serial\n\
device is attached to the remote system (e.g. /dev/ttya).");
target_preopen (from_tty);
- remote_close (0);
+ unpush_target (target);
-#if 0
- dcache_init ();
-#endif
+ remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
- remote_desc = open (name, O_RDWR);
- if (remote_desc < 0)
+ remote_desc = SERIAL_OPEN (name);
+ if (!remote_desc)
perror_with_name (name);
- if (baud_rate)
+ if (baud_rate != -1)
{
- if (1 != sscanf (baud_rate, "%d ", &a_rate))
+ if (SERIAL_SETBAUDRATE (remote_desc, baud_rate))
{
- b_rate = damn_b (a_rate);
- baudrate_set = 1;
+ SERIAL_CLOSE (remote_desc);
+ perror_with_name (name);
}
}
- ioctl (remote_desc, TIOCGETP, &sg);
-#ifdef HAVE_TERMIO
- sg.c_cc[VMIN] = 0; /* read with timeout. */
- sg.c_cc[VTIME] = timeout * 10;
- sg.c_lflag &= ~(ICANON | ECHO);
- sg.c_cflag &= ~PARENB; /* No parity */
- sg.c_cflag |= CS8; /* 8-bit path */
- if (baudrate_set)
- sg.c_cflag = (sg.c_cflag & ~CBAUD) | b_rate;
-#else
- sg.sg_flags |= RAW | ANYP;
- sg.sg_flags &= ~ECHO;
- if (baudrate_set)
- {
- sg.sg_ispeed = b_rate;
- sg.sg_ospeed = b_rate;
- }
-#endif
- ioctl (remote_desc, TIOCSETP, &sg);
-
- if (from_tty)
- printf ("Remote debugging using %s\n", name);
- push_target (&remote_ops); /* Switch to using remote target now */
-
-#ifndef HAVE_TERMIO
-#ifndef NO_SIGINTERRUPT
- /* Cause SIGALRM's to make reads fail. */
- if (siginterrupt (SIGALRM, 1) != 0)
- perror ("remote_open: error in siginterrupt");
-#endif
- /* Set up read timeout timer. */
- if ((void (*)()) signal (SIGALRM, remote_timer) == (void (*)()) -1)
- perror ("remote_open: error in signal");
-#endif
+ SERIAL_RAW (remote_desc);
- /* Ack any packet which the remote side has already sent. */
- write (remote_desc, "+\r", 2);
- putpkt ("?"); /* initiate a query from remote machine */
+ /* If there is something sitting in the buffer we might take it as a
+ response to a command, which would be bad. */
+ SERIAL_FLUSH_INPUT (remote_desc);
- start_remote (); /* Initialize gdb process mechanisms */
+ if (from_tty)
+ {
+ puts_filtered ("Remote debugging using ");
+ puts_filtered (name);
+ puts_filtered ("\n");
+ }
+ push_target (target); /* Switch to using remote target now */
+
+ /* Start out by trying the 'P' request to set registers. We set this each
+ time that we open a new target so that if the user switches from one
+ stub to another, we can (if the target is closed and reopened) cope. */
+ stub_supports_P = 1;
+
+ general_thread = -2;
+ cont_thread = -2;
+
+ /* Without this, some commands which require an active target (such as kill)
+ won't work. This variable serves (at least) double duty as both the pid
+ of the target process (if it has such), and as a flag indicating that a
+ target is active. These functions should be split out into seperate
+ variables, especially since GDB will someday have a notion of debugging
+ several processes. */
+
+ inferior_pid = 42000;
+ /* Start the remote connection; if error (0), discard this target.
+ In particular, if the user quits, be sure to discard it
+ (we'd be in an inconsistent state otherwise). */
+ if (!catch_errors (remote_start_remote, (char *)0,
+ "Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
+ pop_target();
}
-/* remote_detach()
- takes a program previously attached to and detaches it.
- We better not have left any breakpoints
- in the program or it'll die when it hits one.
- Close the open connection to the remote debugger.
- Use this when you want to detach and do something else
- with your gdb. */
+/* This takes a program previously attached to and detaches it. After
+ this is done, GDB can be used to debug some other program. We
+ better not have left any breakpoints in the target program or it'll
+ die when it hits one. */
static void
remote_detach (args, from_tty)
char *args;
int from_tty;
{
+ char buf[PBUFSIZ];
+
if (args)
error ("Argument given to \"detach\" when remotely debugging.");
-
+
+ /* Tell the remote target to detach. */
+ strcpy (buf, "D");
+ remote_send (buf);
+
pop_target ();
if (from_tty)
- printf ("Ending remote debugging.\n");
+ puts_filtered ("Ending remote debugging.\n");
}
/* Convert hex digit A to a number. */
return a - '0';
else if (a >= 'a' && a <= 'f')
return a - 'a' + 10;
- else
- error ("Reply contains invalid hex digit");
- return -1;
+ else
+ error ("Reply contains invalid hex digit %d", a);
}
/* Convert number NIB to a hex digit. */
\f
/* Tell the remote machine to resume. */
+static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
+int last_sent_step;
+
static void
-remote_resume (step, siggnal)
- int step, siggnal;
+remote_resume (pid, step, siggnal)
+ int pid, step;
+ enum target_signal siggnal;
{
char buf[PBUFSIZ];
- if (siggnal)
- error ("Can't send signals to a remote system. Try `handle %d ignore'.",
- siggnal);
+ if (pid == -1)
+ set_thread (inferior_pid, 0);
+ else
+ set_thread (pid, 0);
-#if 0
- dcache_flush ();
-#endif
+ dcache_flush (remote_dcache);
+
+ last_sent_signal = siggnal;
+ last_sent_step = step;
- strcpy (buf, step ? "s": "c");
+ /* A hook for when we need to do something at the last moment before
+ resumption. */
+ if (target_resume_hook)
+ (*target_resume_hook) ();
+
+ if (siggnal != TARGET_SIGNAL_0)
+ {
+ buf[0] = step ? 'S' : 'C';
+ buf[1] = tohex (((int)siggnal >> 4) & 0xf);
+ buf[2] = tohex ((int)siggnal & 0xf);
+ buf[3] = '\0';
+ }
+ else
+ strcpy (buf, step ? "s": "c");
putpkt (buf);
}
-
+\f
/* Send ^C to target to halt it. Target will respond, and send us a
packet. */
-void remote_interrupt(signo)
+static void
+remote_interrupt (signo)
+ int signo;
+{
+ /* If this doesn't work, try more severe steps. */
+ signal (signo, remote_interrupt_twice);
+
+ if (remote_debug)
+ printf_unfiltered ("remote_interrupt called\n");
+
+ /* Send a break or a ^C, depending on user preference. */
+ if (remote_break)
+ SERIAL_SEND_BREAK (remote_desc);
+ else
+ SERIAL_WRITE (remote_desc, "\003", 1);
+}
+
+static void (*ofunc)();
+
+/* The user typed ^C twice. */
+static void
+remote_interrupt_twice (signo)
int signo;
{
+ signal (signo, ofunc);
- if (kiodebug)
- printf ("remote_interrupt called\n");
+ interrupt_query ();
+
+ signal (signo, remote_interrupt);
+}
- write (remote_desc, "\003", 1); /* Send a ^C */
+/* Ask the user what to do when an interrupt is received. */
+
+static void
+interrupt_query ()
+{
+ target_terminal_ours ();
+
+ if (query ("Interrupted while waiting for the program.\n\
+Give up (and stop debugging it)? "))
+ {
+ target_mourn_inferior ();
+ return_to_top_level (RETURN_QUIT);
+ }
+
+ target_terminal_inferior ();
}
+/* If nonzero, ignore the next kill. */
+int kill_kludge;
/* Wait until the remote machine stops, then return,
storing status in STATUS just as `wait' would.
means in the case of this target). */
static int
-remote_wait (status)
- WAITTYPE *status;
+remote_wait (pid, status)
+ int pid;
+ struct target_waitstatus *status;
{
unsigned char buf[PBUFSIZ];
- void (*ofunc)();
- unsigned char *p;
- int i;
- int regno;
- unsigned char regs[8]; /* Better be big enough for largest reg */
+ int thread_num = -1;
- WSETEXIT ((*status), 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
- ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
- getpkt ((char *) buf);
- signal (SIGINT, ofunc);
-
- if (buf[0] == 'E')
- error ("Remote failure reply: %s", buf);
- if (buf[0] == 'T')
+ while (1)
{
- /* Expedited reply, containing Signal, {regno, reg} repeat */
- p = &buf[3]; /* after Txx */
+ unsigned char *p;
- while (*p)
- {
- regno = fromhex (p[0]) * 16 + fromhex (p[1]);
- p += 2;
- if (regno >= NUM_REGS)
- error ("Remote sent illegal register number %d (0x%x)", regno,
- regno);
+ ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
+ getpkt ((char *) buf, 1);
+ signal (SIGINT, ofunc);
- for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
+ /* This is a hook for when we need to do something (perhaps the
+ collection of trace data) every time the target stops. */
+ if (target_wait_loop_hook)
+ (*target_wait_loop_hook) ();
+
+ switch (buf[0])
+ {
+ case 'E': /* Error of some sort */
+ warning ("Remote failure reply: %s", buf);
+ continue;
+ case 'T': /* Status with PC, SP, FP, ... */
+ {
+ int i;
+ long regno;
+ char regs[MAX_REGISTER_RAW_SIZE];
+
+ /* Expedited reply, containing Signal, {regno, reg} repeat */
+ /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
+ ss = signal number
+ n... = register number
+ r... = register contents
+ */
+
+ p = &buf[3]; /* after Txx */
+
+ while (*p)
+ {
+ unsigned char *p1;
+ char *p_temp;
+
+ regno = strtol ((const char *) p, &p_temp, 16); /* Read the register number */
+ p1 = (unsigned char *)p_temp;
+
+ if (p1 == p)
+ {
+ p1 = (unsigned char *) strchr ((const char *) p, ':');
+ if (p1 == NULL)
+ warning ("Malformed packet (missing colon): %s\n\
+Packet: '%s'\n",
+ p, buf);
+ if (strncmp ((const char *) p, "thread", p1 - p) == 0)
+ {
+ thread_num = strtol ((const char *) ++p1, &p_temp, 16);
+ p = (unsigned char *)p_temp;
+ }
+ }
+ else
+ {
+ p = p1;
+
+ if (*p++ != ':')
+ warning ("Malformed packet (missing colon): %s\n\
+Packet: '%s'\n",
+ p, buf);
+
+ if (regno >= NUM_REGS)
+ warning ("Remote sent bad register number %ld: %s\n\
+Packet: '%s'\n",
+ regno, p, buf);
+
+ for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
+ {
+ if (p[0] == 0 || p[1] == 0)
+ warning ("Remote reply is too short: %s", buf);
+ regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
+ p += 2;
+ }
+ supply_register (regno, regs);
+ }
+
+ if (*p++ != ';')
+ warning ("Remote register badly formatted: %s", buf);
+ }
+ }
+ /* fall through */
+ case 'S': /* Old style status, just signal only */
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = (enum target_signal)
+ (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
+
+ goto got_status;
+ case 'W': /* Target exited */
+ {
+ /* The remote process exited. */
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = (fromhex (buf[1]) << 4) + fromhex (buf[2]);
+ goto got_status;
+ }
+ case 'X':
+ status->kind = TARGET_WAITKIND_SIGNALLED;
+ status->value.sig = (enum target_signal)
+ (((fromhex (buf[1])) << 4) + (fromhex (buf[2])));
+ kill_kludge = 1;
+
+ goto got_status;
+ case 'O': /* Console output */
+ for (p = buf + 1; *p; p +=2)
+ {
+ char tb[2];
+ char c = fromhex (p[0]) * 16 + fromhex (p[1]);
+ tb[0] = c;
+ tb[1] = 0;
+ if (target_output_hook)
+ target_output_hook (tb);
+ else
+ fputs_filtered (tb, gdb_stdout);
+ }
+ continue;
+ case '\0':
+ if (last_sent_signal != TARGET_SIGNAL_0)
{
- if (p[0] == 0 || p[1] == 0)
- error ("Remote reply is too short: %s", buf);
- regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
- p += 2;
+ /* Zero length reply means that we tried 'S' or 'C' and
+ the remote system doesn't support it. */
+ target_terminal_ours_for_output ();
+ printf_filtered
+ ("Can't send signals to this remote system. %s not sent.\n",
+ target_signal_to_name (last_sent_signal));
+ last_sent_signal = TARGET_SIGNAL_0;
+ target_terminal_inferior ();
+
+ strcpy ((char *) buf, last_sent_step ? "s" : "c");
+ putpkt ((char *) buf);
+ continue;
}
-
- supply_register (regno, regs);
+ /* else fallthrough */
+ default:
+ warning ("Invalid remote reply: %s", buf);
+ continue;
}
}
- else if (buf[0] != 'S')
- error ("Invalid remote reply: %s", buf);
-
- WSETSTOP ((*status), (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))));
-
- return 0;
+ got_status:
+ if (thread_num != -1)
+ {
+ /* Initial thread value can only be acquired via wait, so deal with
+ this marker which is used before the first thread value is
+ acquired. */
+ if (inferior_pid == 42000)
+ {
+ inferior_pid = thread_num;
+ add_thread (inferior_pid);
+ }
+ return thread_num;
+ }
+ return inferior_pid;
}
+/* Number of bytes of registers this stub implements. */
+static int register_bytes_found;
+
/* Read the remote registers into the block REGS. */
/* Currently we just read all the registers, so we don't use regno. */
/* ARGSUSED */
char *p;
char regs[REGISTER_BYTES];
+ set_thread (inferior_pid, 1);
+
sprintf (buf, "g");
remote_send (buf);
+ if (remote_register_buf_size == 0)
+ remote_register_buf_size = strlen (buf);
+
+ /* Unimplemented registers read as all bits zero. */
+ memset (regs, 0, REGISTER_BYTES);
+
+ /* We can get out of synch in various cases. If the first character
+ in the buffer is not a hex character, assume that has happened
+ and try to fetch another packet to read. */
+ while ((buf[0] < '0' || buf[0] > '9')
+ && (buf[0] < 'a' || buf[0] > 'f'))
+ {
+ if (remote_debug)
+ printf_unfiltered ("Bad register packet; fetching a new packet\n");
+ getpkt (buf, 0);
+ }
+
/* Reply describes registers byte by byte, each byte encoded as two
hex characters. Suck them all up, then supply them to the
register cacheing/storage mechanism. */
p = buf;
for (i = 0; i < REGISTER_BYTES; i++)
{
- if (p[0] == 0 || p[1] == 0)
- error ("Remote reply is too short: %s", buf);
+ if (p[0] == 0)
+ break;
+ if (p[1] == 0)
+ {
+ warning ("Remote reply is of odd length: %s", buf);
+ /* Don't change register_bytes_found in this case, and don't
+ print a second warning. */
+ goto supply_them;
+ }
regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
+
+ if (i != register_bytes_found)
+ {
+ register_bytes_found = i;
+#ifdef REGISTER_BYTES_OK
+ if (!REGISTER_BYTES_OK (i))
+ warning ("Remote reply is too short: %s", buf);
+#endif
+ }
+
+ supply_them:
for (i = 0; i < NUM_REGS; i++)
supply_register (i, ®s[REGISTER_BYTE(i)]);
}
-/* Prepare to store registers. Since we send them all, we have to
- read out the ones we don't want to change first. */
+/* Prepare to store registers. Since we may send them all (using a
+ 'G' request), we have to read out the ones we don't want to change
+ first. */
static void
remote_prepare_to_store ()
{
- remote_fetch_registers (-1);
+ /* Make sure the entire registers array is valid. */
+ read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
}
-/* Store the remote registers from the contents of the block REGISTERS.
- FIXME, eventually just store one register if that's all that is needed. */
+/* Store register REGNO, or all registers if REGNO == -1, from the contents
+ of REGISTERS. FIXME: ignores errors. */
-/* ARGSUSED */
static void
remote_store_registers (regno)
int regno;
int i;
char *p;
+ set_thread (inferior_pid, 1);
+
+ if (regno >= 0 && stub_supports_P)
+ {
+ /* Try storing a single register. */
+ char *regp;
+
+ sprintf (buf, "P%x=", regno);
+ p = buf + strlen (buf);
+ regp = ®isters[REGISTER_BYTE (regno)];
+ for (i = 0; i < REGISTER_RAW_SIZE (regno); ++i)
+ {
+ *p++ = tohex ((regp[i] >> 4) & 0xf);
+ *p++ = tohex (regp[i] & 0xf);
+ }
+ *p = '\0';
+ remote_send (buf);
+ if (buf[0] != '\0')
+ {
+ /* The stub understands the 'P' request. We are done. */
+ return;
+ }
+
+ /* The stub does not support the 'P' request. Use 'G' instead,
+ and don't try using 'P' in the future (it will just waste our
+ time). */
+ stub_supports_P = 0;
+ }
+
buf[0] = 'G';
-
+
/* Command describes registers byte by byte,
each byte encoded as two hex characters. */
p = buf + 1;
- for (i = 0; i < REGISTER_BYTES; i++)
+ /* remote_prepare_to_store insures that register_bytes_found gets set. */
+ for (i = 0; i < register_bytes_found; i++)
{
*p++ = tohex ((registers[i] >> 4) & 0xf);
*p++ = tohex (registers[i] & 0xf);
remote_send (buf);
}
-#if 0
+/*
+ Use of the data cache *used* to be disabled because it loses for looking at
+ and changing hardware I/O ports and the like. Accepting `volatile'
+ would perhaps be one way to fix it. Another idea would be to use the
+ executable file for the text segment (for all SEC_CODE sections?
+ For all SEC_READONLY sections?). This has problems if you want to
+ actually see what the memory contains (e.g. self-modifying code,
+ clobbered memory, user downloaded the wrong thing).
+
+ Because it speeds so much up, it's now enabled, if you're playing
+ with registers you turn it of (set remotecache 0)
+*/
+
/* Read a word from remote address ADDR and return it.
This goes through the data cache. */
-int
+#if 0 /* unused? */
+static int
remote_fetch_word (addr)
CORE_ADDR addr;
{
- if (icache)
- {
- extern CORE_ADDR text_start, text_end;
-
- if (addr >= text_start && addr < text_end)
- {
- int buffer;
- xfer_core_file (addr, &buffer, sizeof (int));
- return buffer;
- }
- }
- return dcache_fetch (addr);
-}
+ return dcache_fetch (remote_dcache, addr);
+}
/* Write a word WORD into remote address ADDR.
This goes through the data cache. */
-void
+static void
remote_store_word (addr, word)
CORE_ADDR addr;
int word;
{
- dcache_poke (addr, word);
+ dcache_poke (remote_dcache, addr, word);
}
-#endif /* 0 */
+#endif /* 0 (unused?) */
+
\f
+
+/* Return the number of hex digits in num. */
+
+static int
+hexnumlen (num)
+ ULONGEST num;
+{
+ int i;
+
+ for (i = 0; num != 0; i++)
+ num >>= 4;
+
+ return min (i, 1);
+}
+
/* Write memory data directly to the remote machine.
This does not inform the data cache; the data cache uses this.
MEMADDR is the address in the remote memory space.
MYADDR is the address of the buffer in our space.
- LEN is the number of bytes. */
+ LEN is the number of bytes.
-static void
+ Returns number of bytes transferred, or 0 for error. */
+
+static int
remote_write_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
char *myaddr;
int len;
{
- char buf[PBUFSIZ];
- int i;
- char *p;
+ int max_buf_size; /* Max size of packet output buffer */
+ int origlen;
- if (len > PBUFSIZ / 2 - 20)
- abort ();
+ /* Chop the transfer down if necessary */
- sprintf (buf, "M%x,%x:", memaddr, len);
+ max_buf_size = min (remote_write_size, PBUFSIZ);
+ max_buf_size = min (max_buf_size, remote_register_buf_size);
- /* We send target system values byte by byte, in increasing byte addresses,
- each byte encoded as two hex characters. */
+#define PACKET_OVERHEAD (1 + 1 + 1 + 2) /* $x#xx - Overhead for all types of packets */
+
+ /* packet overhead + <memaddr>,<len>: */
+ max_buf_size -= PACKET_OVERHEAD + hexnumlen (memaddr + len - 1) + 1 + hexnumlen (len) + 1;
- p = buf + strlen (buf);
- for (i = 0; i < len; i++)
+ origlen = len;
+ while (len > 0)
{
- *p++ = tohex ((myaddr[i] >> 4) & 0xf);
- *p++ = tohex (myaddr[i] & 0xf);
- }
- *p = '\0';
+ char buf[PBUFSIZ];
+ char *p;
+ int todo;
+ int i;
- remote_send (buf);
+ todo = min (len, max_buf_size / 2); /* num bytes that will fit */
+
+ /* FIXME-32x64: Need a version of print_address_numeric which puts the
+ result in a buffer like sprintf. */
+ sprintf (buf, "M%lx,%x:", (unsigned long) memaddr, todo);
+
+ /* We send target system values byte by byte, in increasing byte addresses,
+ each byte encoded as two hex characters. */
+
+ p = buf + strlen (buf);
+ for (i = 0; i < todo; i++)
+ {
+ *p++ = tohex ((myaddr[i] >> 4) & 0xf);
+ *p++ = tohex (myaddr[i] & 0xf);
+ }
+ *p = '\0';
+
+ putpkt (buf);
+ getpkt (buf, 0);
+
+ if (buf[0] == 'E')
+ {
+ /* There is no correspondance between what the remote protocol uses
+ for errors and errno codes. We would like a cleaner way of
+ representing errors (big enough to include errno codes, bfd_error
+ codes, and others). But for now just return EIO. */
+ errno = EIO;
+ return 0;
+ }
+ myaddr += todo;
+ memaddr += todo;
+ len -= todo;
+ }
+ return origlen;
}
/* Read memory data directly from the remote machine.
This does not use the data cache; the data cache uses this.
MEMADDR is the address in the remote memory space.
MYADDR is the address of the buffer in our space.
- LEN is the number of bytes. */
+ LEN is the number of bytes.
-static void
+ Returns number of bytes transferred, or 0 for error. */
+
+static int
remote_read_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
char *myaddr;
int len;
{
- char buf[PBUFSIZ];
- int i;
- char *p;
+ int max_buf_size; /* Max size of packet output buffer */
+ int origlen;
- if (len > PBUFSIZ / 2 - 1)
- abort ();
+ /* Chop the transfer down if necessary */
- sprintf (buf, "m%x,%x", memaddr, len);
- remote_send (buf);
+ max_buf_size = min (remote_write_size, PBUFSIZ);
+ max_buf_size = min (max_buf_size, remote_register_buf_size);
+
+ /* packet overhead */
+ max_buf_size -= PACKET_OVERHEAD;
+
+ origlen = len;
+ while (len > 0)
+ {
+ char buf[PBUFSIZ];
+ char *p;
+ int todo;
+ int i;
+
+ todo = min (len, max_buf_size / 2); /* num bytes that will fit */
+
+ /* FIXME-32x64: Need a version of print_address_numeric which puts the
+ result in a buffer like sprintf. */
+ sprintf (buf, "m%lx,%x", (unsigned long) memaddr, todo);
+ putpkt (buf);
+ getpkt (buf, 0);
+
+ if (buf[0] == 'E')
+ {
+ /* There is no correspondance between what the remote protocol uses
+ for errors and errno codes. We would like a cleaner way of
+ representing errors (big enough to include errno codes, bfd_error
+ codes, and others). But for now just return EIO. */
+ errno = EIO;
+ return 0;
+ }
/* Reply describes memory byte by byte,
each byte encoded as two hex characters. */
- p = buf;
- for (i = 0; i < len; i++)
- {
- if (p[0] == 0 || p[1] == 0)
- error ("Remote reply is too short: %s", buf);
- myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
- p += 2;
+ p = buf;
+ for (i = 0; i < todo; i++)
+ {
+ if (p[0] == 0 || p[1] == 0)
+ /* Reply is short. This means that we were able to read only part
+ of what we wanted to. */
+ return i + (origlen - len);
+ myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
+ p += 2;
+ }
+ myaddr += todo;
+ memaddr += todo;
+ len -= todo;
}
+ return origlen;
}
\f
/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
int should_write;
struct target_ops *target; /* ignored */
{
- int origlen = len;
- int xfersize;
- while (len > 0)
+ return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, should_write);
+}
+
+
+#if 0
+/* Enable after 4.12. */
+
+void
+remote_search (len, data, mask, startaddr, increment, lorange, hirange
+ addr_found, data_found)
+ int len;
+ char *data;
+ char *mask;
+ CORE_ADDR startaddr;
+ int increment;
+ CORE_ADDR lorange;
+ CORE_ADDR hirange;
+ CORE_ADDR *addr_found;
+ char *data_found;
+{
+ if (increment == -4 && len == 4)
{
- if (len > MAXBUFBYTES)
- xfersize = MAXBUFBYTES;
- else
- xfersize = len;
+ long mask_long, data_long;
+ long data_found_long;
+ CORE_ADDR addr_we_found;
+ char buf[PBUFSIZ];
+ long returned_long[2];
+ char *p;
+
+ mask_long = extract_unsigned_integer (mask, len);
+ data_long = extract_unsigned_integer (data, len);
+ sprintf (buf, "t%x:%x,%x", startaddr, data_long, mask_long);
+ putpkt (buf);
+ getpkt (buf, 0);
+ if (buf[0] == '\0')
+ {
+ /* The stub doesn't support the 't' request. We might want to
+ remember this fact, but on the other hand the stub could be
+ switched on us. Maybe we should remember it only until
+ the next "target remote". */
+ generic_search (len, data, mask, startaddr, increment, lorange,
+ hirange, addr_found, data_found);
+ return;
+ }
- if (should_write)
- remote_write_bytes(memaddr, myaddr, xfersize);
- else
- remote_read_bytes (memaddr, myaddr, xfersize);
- memaddr += xfersize;
- myaddr += xfersize;
- len -= xfersize;
+ if (buf[0] == 'E')
+ /* There is no correspondance between what the remote protocol uses
+ for errors and errno codes. We would like a cleaner way of
+ representing errors (big enough to include errno codes, bfd_error
+ codes, and others). But for now just use EIO. */
+ memory_error (EIO, startaddr);
+ p = buf;
+ addr_we_found = 0;
+ while (*p != '\0' && *p != ',')
+ addr_we_found = (addr_we_found << 4) + fromhex (*p++);
+ if (*p == '\0')
+ error ("Protocol error: short return for search");
+
+ data_found_long = 0;
+ while (*p != '\0' && *p != ',')
+ data_found_long = (data_found_long << 4) + fromhex (*p++);
+ /* Ignore anything after this comma, for future extensions. */
+
+ if (addr_we_found < lorange || addr_we_found >= hirange)
+ {
+ *addr_found = 0;
+ return;
+ }
+
+ *addr_found = addr_we_found;
+ *data_found = store_unsigned_integer (data_we_found, len);
+ return;
}
- return origlen; /* no error possible */
+ generic_search (len, data, mask, startaddr, increment, lorange,
+ hirange, addr_found, data_found);
}
-
+#endif /* 0 */
+\f
static void
remote_files_info (ignore)
-struct target_ops *ignore;
+ struct target_ops *ignore;
{
- printf ("Debugging a target over a serial line.\n");
+ puts_filtered ("Debugging a target over a serial line.\n");
}
\f
-/*
-
-A debug packet whose contents are <data>
-is encapsulated for transmission in the form:
-
- $ <data> # CSUM1 CSUM2
-
- <data> must be ASCII alphanumeric and cannot include characters
- '$' or '#'
-
- CSUM1 and CSUM2 are ascii hex representation of an 8-bit
- checksum of <data>, the most significant nibble is sent first.
- the hex digits 0-9,a-f are used.
-
-Receiver responds with:
+/* Stuff for dealing with the packets which are part of this protocol.
+ See comment at top of file for details. */
- + - if CSUM is correct and ready for next packet
- - - if CSUM is incorrect
-
-*/
-
-/* Read a single character from the remote end.
- (If supported, we actually read many characters and buffer them up.) */
+/* Read a single character from the remote end, masking it down to 7 bits. */
static int
-readchar ()
+readchar (timeout)
+ int timeout;
{
- static int inbuf_index, inbuf_count;
-#define INBUFSIZE PBUFSIZ
- static char inbuf[INBUFSIZE];
+ int ch;
+
+ ch = SERIAL_READCHAR (remote_desc, timeout);
- if (inbuf_index >= inbuf_count)
+ switch (ch)
{
- /* Time to do another read... */
- inbuf_index = 0;
- inbuf_count = 0;
- inbuf[0] = 0; /* Just in case */
-#ifdef HAVE_TERMIO
- /* termio does the timeout for us. */
- inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
-#else
- alarm (timeout);
- inbuf_count = read (remote_desc, inbuf, INBUFSIZE);
- alarm (0);
-#endif
+ case SERIAL_EOF:
+ error ("Remote connection closed");
+ case SERIAL_ERROR:
+ perror_with_name ("Remote communication error");
+ case SERIAL_TIMEOUT:
+ return ch;
+ default:
+ return ch & 0x7f;
}
-
- /* Just return the next character from the buffer. */
- return inbuf[inbuf_index++] & 0x7f;
}
/* Send the command in BUF to the remote machine,
remote_send (buf)
char *buf;
{
-
putpkt (buf);
- getpkt (buf);
+ getpkt (buf, 0);
if (buf[0] == 'E')
error ("Remote failure reply: %s", buf);
/* Send a packet to the remote machine, with error checking.
The data of the packet is in BUF. */
-static void
+static int
putpkt (buf)
char *buf;
{
unsigned char csum = 0;
char buf2[PBUFSIZ];
int cnt = strlen (buf);
- char ch;
+ int ch;
+ int tcount = 0;
char *p;
/* Copy the packet into buffer BUF2, encapsulating it
and giving it a checksum. */
- if (cnt > sizeof(buf2) - 5) /* Prosanity check */
+ if (cnt > (int) sizeof (buf2) - 5) /* Prosanity check */
abort();
p = buf2;
/* Send it over and over until we get a positive ack. */
- do {
- if (kiodebug)
- {
- *p = '\0';
- printf ("Sending packet: %s...", buf2); fflush(stdout);
- }
- write (remote_desc, buf2, p - buf2);
-
- /* read until either a timeout occurs (\0) or '+' is read */
- do {
- ch = readchar ();
- if (kiodebug) {
- if (ch == '+')
- printf("Ack\n");
- else
- printf ("%02X%c ", ch&0xFF, ch);
- }
- } while ((ch != '+') && (ch != '\0'));
- } while (ch != '+');
+ while (1)
+ {
+ int started_error_output = 0;
+
+ if (remote_debug)
+ {
+ *p = '\0';
+ printf_unfiltered ("Sending packet: %s...", buf2);
+ gdb_flush(gdb_stdout);
+ }
+ if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
+ perror_with_name ("putpkt: write failed");
+
+ /* read until either a timeout occurs (-2) or '+' is read */
+ while (1)
+ {
+ ch = readchar (remote_timeout);
+
+ if (remote_debug)
+ {
+ switch (ch)
+ {
+ case '+':
+ case SERIAL_TIMEOUT:
+ case '$':
+ if (started_error_output)
+ {
+ putchar_unfiltered ('\n');
+ started_error_output = 0;
+ }
+ }
+ }
+
+ switch (ch)
+ {
+ case '+':
+ if (remote_debug)
+ printf_unfiltered("Ack\n");
+ return 1;
+ case SERIAL_TIMEOUT:
+ tcount ++;
+ if (tcount > 3)
+ return 0;
+ break; /* Retransmit buffer */
+ case '$':
+ {
+ char junkbuf[PBUFSIZ];
+
+ /* It's probably an old response, and we're out of sync. Just
+ gobble up the packet and ignore it. */
+ getpkt (junkbuf, 0);
+ continue; /* Now, go look for + */
+ }
+ default:
+ if (remote_debug)
+ {
+ if (!started_error_output)
+ {
+ started_error_output = 1;
+ printf_unfiltered ("putpkt: Junk: ");
+ }
+ putchar_unfiltered (ch & 0177);
+ }
+ continue;
+ }
+ break; /* Here to retransmit */
+ }
+
+#if 0
+ /* This is wrong. If doing a long backtrace, the user should be
+ able to get out next time we call QUIT, without anything as violent
+ as interrupt_query. If we want to provide a way out of here
+ without getting to the next QUIT, it should be based on hitting
+ ^C twice as in remote_wait. */
+ if (quit_flag)
+ {
+ quit_flag = 0;
+ interrupt_query ();
+ }
+#endif
+ }
}
-/* Read a packet from the remote machine, with error checking,
- and store it in BUF. BUF is expected to be of size PBUFSIZ. */
+/* Come here after finding the start of the frame. Collect the rest into BUF,
+ verifying the checksum, length, and handling run-length compression.
+ Returns 0 on any error, 1 on success. */
-static void
-getpkt (buf)
+static int
+read_frame (buf)
char *buf;
{
- char *bp;
unsigned char csum;
+ char *bp;
int c;
- unsigned char c1, c2;
- int retries = 0;
-#define MAX_RETRIES 10
-#if 0
- /* Sorry, this will cause all hell to break loose, i.e. we'll end
- up in the command loop with an inferior, but (at least if this
- happens in remote_wait or some such place) without a current_frame,
- having set up prev_* in wait_for_inferior, etc.
-
- If it is necessary to have such an "emergency exit", seems like
- the only plausible thing to do is to say the inferior died, and
- make the user reattach if they want to. Perhaps with a prompt
- asking for confirmation. */
-
- /* allow immediate quit while reading from device, it could be hung */
- immediate_quit++;
-#endif /* 0 */
+ csum = 0;
+ bp = buf;
while (1)
{
- /* Force csum to be zero here because of possible error retry. */
- csum = 0;
-
- while ((c = readchar()) != '$');
+ c = readchar (remote_timeout);
- bp = buf;
- while (1)
+ switch (c)
{
- c = readchar ();
- if (c == '#')
- break;
- if (bp >= buf+PBUFSIZ-1)
+ case SERIAL_TIMEOUT:
+ if (remote_debug)
+ puts_filtered ("Timeout in mid-packet, retrying\n");
+ return 0;
+ case '$':
+ if (remote_debug)
+ puts_filtered ("Saw new packet start in middle of old one\n");
+ return 0; /* Start a new packet, count retries */
+ case '#':
{
- *bp = '\0';
- printf_filtered ("Remote packet too long: %s\n", buf);
- goto whole;
+ unsigned char pktcsum;
+
+ *bp = '\000';
+
+ pktcsum = fromhex (readchar (remote_timeout)) << 4;
+ pktcsum |= fromhex (readchar (remote_timeout));
+
+ if (csum == pktcsum)
+ return 1;
+
+ if (remote_debug)
+ {
+ printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
+ pktcsum, csum);
+ puts_filtered (buf);
+ puts_filtered ("\n");
+ }
+ return 0;
}
- *bp++ = c;
+ case '*': /* Run length encoding */
csum += c;
- }
- *bp = 0;
+ c = readchar (remote_timeout);
+ csum += c;
+ c = c - ' ' + 3; /* Compute repeat count */
- c1 = fromhex (readchar ());
- c2 = fromhex (readchar ());
- if ((csum & 0xff) == (c1 << 4) + c2)
- break;
- printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
- (c1 << 4) + c2, csum & 0xff, buf);
- /* Try the whole thing again. */
-whole:
- if (++retries < MAX_RETRIES)
- {
- write (remote_desc, "-", 1);
- }
- else
- {
- printf ("Ignoring packet error, continuing...\n");
- break;
+ if (c > 0 && c < 255 && bp + c - 1 < buf + PBUFSIZ - 1)
+ {
+ memset (bp, *(bp - 1), c);
+ bp += c;
+ continue;
+ }
+
+ *bp = '\0';
+ printf_filtered ("Repeat count %d too large for buffer: ", c);
+ puts_filtered (buf);
+ puts_filtered ("\n");
+ return 0;
+
+ default:
+ if (bp < buf + PBUFSIZ - 1)
+ {
+ *bp++ = c;
+ csum += c;
+ continue;
+ }
+
+ *bp = '\0';
+ puts_filtered ("Remote packet too long: ");
+ puts_filtered (buf);
+ puts_filtered ("\n");
+
+ return 0;
}
}
+}
-#if 0
- immediate_quit--;
+/* Read a packet from the remote machine, with error checking,
+ and store it in BUF. BUF is expected to be of size PBUFSIZ.
+ If FOREVER, wait forever rather than timing out; this is used
+ while the target is executing user code. */
+
+static void
+getpkt (buf, forever)
+ char *buf;
+ int forever;
+{
+ int c;
+ int tries;
+ int timeout;
+ int val;
+
+ strcpy (buf,"timeout");
+
+ if (forever)
+ {
+#ifdef MAINTENANCE_CMDS
+ timeout = watchdog > 0 ? watchdog : -1;
+#else
+ timeout = -1;
#endif
+ }
- write (remote_desc, "+", 1);
+ else
+ timeout = remote_timeout;
- if (kiodebug)
- fprintf (stderr,"Packet received: %s\n", buf);
-}
-\f
-/* The data cache leads to incorrect results because it doesn't know about
- volatile variables, thus making it impossible to debug functions which
- use hardware registers. Therefore it is #if 0'd out. Effect on
- performance is some, for backtraces of functions with a few
- arguments each. For functions with many arguments, the stack
- frames don't fit in the cache blocks, which makes the cache less
- helpful. Disabling the cache is a big performance win for fetching
- large structures, because the cache code fetched data in 16-byte
- chunks. */
-#if 0
-/* The data cache records all the data read from the remote machine
- since the last time it stopped.
+#define MAX_TRIES 3
- Each cache block holds 16 bytes of data
- starting at a multiple-of-16 address. */
+ for (tries = 1; tries <= MAX_TRIES; tries++)
+ {
+ /* This can loop forever if the remote side sends us characters
+ continuously, but if it pauses, we'll get a zero from readchar
+ because of timeout. Then we'll count that as a retry. */
-#define DCACHE_SIZE 64 /* Number of cache blocks */
+ /* Note that we will only wait forever prior to the start of a packet.
+ After that, we expect characters to arrive at a brisk pace. They
+ should show up within remote_timeout intervals. */
-struct dcache_block {
- struct dcache_block *next, *last;
- unsigned int addr; /* Address for which data is recorded. */
- int data[4];
-};
+ do
+ {
+ c = readchar (timeout);
-struct dcache_block dcache_free, dcache_valid;
+ if (c == SERIAL_TIMEOUT)
+ {
+#ifdef MAINTENANCE_CMDS
+ if (forever) /* Watchdog went off. Kill the target. */
+ {
+ target_mourn_inferior ();
+ error ("Watchdog has expired. Target detached.\n");
+ }
+#endif
+ if (remote_debug)
+ puts_filtered ("Timed out.\n");
+ goto retry;
+ }
+ }
+ while (c != '$');
+
+ /* We've found the start of a packet, now collect the data. */
-/* Free all the data cache blocks, thus discarding all cached data. */
+ val = read_frame (buf);
+ if (val == 1)
+ {
+ if (remote_debug)
+ fprintf_unfiltered (gdb_stderr, "Packet received: %s\n", buf);
+ SERIAL_WRITE (remote_desc, "+", 1);
+ return;
+ }
+
+ /* Try the whole thing again. */
+ retry:
+ SERIAL_WRITE (remote_desc, "-", 1);
+ }
+
+ /* We have tried hard enough, and just can't receive the packet. Give up. */
+
+ printf_unfiltered ("Ignoring packet error, continuing...\n");
+ SERIAL_WRITE (remote_desc, "+", 1);
+}
+\f
static void
-dcache_flush ()
+remote_kill ()
{
- register struct dcache_block *db;
-
- while ((db = dcache_valid.next) != &dcache_valid)
+ /* For some mysterious reason, wait_for_inferior calls kill instead of
+ mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
+ if (kill_kludge)
{
- remque (db);
- insque (db, &dcache_free);
+ kill_kludge = 0;
+ target_mourn_inferior ();
+ return;
}
-}
-/*
- * If addr is present in the dcache, return the address of the block
- * containing it.
- */
+ /* Use catch_errors so the user can quit from gdb even when we aren't on
+ speaking terms with the remote system. */
+ catch_errors (putpkt, "k", "", RETURN_MASK_ERROR);
+
+ /* Don't wait for it to die. I'm not really sure it matters whether
+ we do or not. For the existing stubs, kill is a noop. */
+ target_mourn_inferior ();
+}
-struct dcache_block *
-dcache_hit (addr)
+static void
+remote_mourn ()
{
- register struct dcache_block *db;
+ remote_mourn_1 (&remote_ops);
+}
- if (addr & 3)
- abort ();
+static void
+extended_remote_mourn ()
+{
+ /* We do _not_ want to mourn the target like this; this will
+ remove the extended remote target from the target stack,
+ and the next time the user says "run" it'll fail.
- /* Search all cache blocks for one that is at this address. */
- db = dcache_valid.next;
- while (db != &dcache_valid)
- {
- if ((addr & 0xfffffff0) == db->addr)
- return db;
- db = db->next;
- }
- return NULL;
+ FIXME: What is the right thing to do here? */
+#if 0
+ remote_mourn_1 (&extended_remote_ops);
+#endif
}
-/* Return the int data at address ADDR in dcache block DC. */
-
-int
-dcache_value (db, addr)
- struct dcache_block *db;
- unsigned int addr;
+/* Worker function for remote_mourn. */
+static void
+remote_mourn_1 (target)
+ struct target_ops *target;
{
- if (addr & 3)
- abort ();
- return (db->data[(addr>>2)&3]);
+ unpush_target (target);
+ generic_mourn_inferior ();
}
-/* Get a free cache block, put it on the valid list,
- and return its address. The caller should store into the block
- the address and data that it describes. */
+/* In the extended protocol we want to be able to do things like
+ "run" and have them basically work as expected. So we need
+ a special create_inferior function.
-struct dcache_block *
-dcache_alloc ()
+ FIXME: One day add support for changing the exec file
+ we're debugging, arguments and an environment. */
+
+static void
+extended_remote_create_inferior (exec_file, args, env)
+ char *exec_file;
+ char *args;
+ char **env;
{
- register struct dcache_block *db;
+ /* Rip out the breakpoints; we'll reinsert them after restarting
+ the remote server. */
+ remove_breakpoints ();
+
+ /* Now restart the remote server. */
+ extended_remote_restart ();
- if ((db = dcache_free.next) == &dcache_free)
- /* If we can't get one from the free list, take last valid */
- db = dcache_valid.last;
+ /* Now put the breakpoints back in. This way we're safe if the
+ restart function works via a unix fork on the remote side. */
+ insert_breakpoints ();
- remque (db);
- insque (db, &dcache_valid);
- return (db);
+ /* Clean up from the last time we were running. */
+ clear_proceed_status ();
+
+ /* Let the remote process run. */
+ proceed (-1, TARGET_SIGNAL_0, 0);
}
-/* Return the contents of the word at address ADDR in the remote machine,
- using the data cache. */
+\f
+/* On some machines, e.g. 68k, we may use a different breakpoint instruction
+ than other targets; in those use REMOTE_BREAKPOINT instead of just
+ BREAKPOINT. Also, bi-endian targets may define LITTLE_REMOTE_BREAKPOINT
+ and BIG_REMOTE_BREAKPOINT. If none of these are defined, we just call
+ the standard routines that are in mem-break.c. */
+
+/* FIXME, these ought to be done in a more dynamic fashion. For instance,
+ the choice of breakpoint instruction affects target program design and
+ vice versa, and by making it user-tweakable, the special code here
+ goes away and we need fewer special GDB configurations. */
+
+#if defined (LITTLE_REMOTE_BREAKPOINT) && defined (BIG_REMOTE_BREAKPOINT) && !defined(REMOTE_BREAKPOINT)
+#define REMOTE_BREAKPOINT
+#endif
-int
-dcache_fetch (addr)
- CORE_ADDR addr;
-{
- register struct dcache_block *db;
+#ifdef REMOTE_BREAKPOINT
- db = dcache_hit (addr);
- if (db == 0)
- {
- db = dcache_alloc ();
- remote_read_bytes (addr & ~0xf, db->data, 16);
- db->addr = addr & ~0xf;
- }
- return (dcache_value (db, addr));
-}
+/* If the target isn't bi-endian, just pretend it is. */
+#if !defined (LITTLE_REMOTE_BREAKPOINT) && !defined (BIG_REMOTE_BREAKPOINT)
+#define LITTLE_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
+#define BIG_REMOTE_BREAKPOINT REMOTE_BREAKPOINT
+#endif
+
+static unsigned char big_break_insn[] = BIG_REMOTE_BREAKPOINT;
+static unsigned char little_break_insn[] = LITTLE_REMOTE_BREAKPOINT;
+
+#endif /* REMOTE_BREAKPOINT */
-/* Write the word at ADDR both in the data cache and in the remote machine. */
+/* Insert a breakpoint on targets that don't have any better breakpoint
+ support. We read the contents of the target location and stash it,
+ then overwrite it with a breakpoint instruction. ADDR is the target
+ location in the target machine. CONTENTS_CACHE is a pointer to
+ memory allocated for saving the target contents. It is guaranteed
+ by the caller to be long enough to save sizeof BREAKPOINT bytes (this
+ is accomplished via BREAKPOINT_MAX). */
-dcache_poke (addr, data)
+static int
+remote_insert_breakpoint (addr, contents_cache)
CORE_ADDR addr;
- int data;
+ char *contents_cache;
{
- register struct dcache_block *db;
+#ifdef REMOTE_BREAKPOINT
+ int val;
+
+ val = target_read_memory (addr, contents_cache, sizeof big_break_insn);
- /* First make sure the word is IN the cache. DB is its cache block. */
- db = dcache_hit (addr);
- if (db == 0)
+ if (val == 0)
{
- db = dcache_alloc ();
- remote_read_bytes (addr & ~0xf, db->data, 16);
- db->addr = addr & ~0xf;
+ if (TARGET_BYTE_ORDER == BIG_ENDIAN)
+ val = target_write_memory (addr, (char *) big_break_insn,
+ sizeof big_break_insn);
+ else
+ val = target_write_memory (addr, (char *) little_break_insn,
+ sizeof little_break_insn);
}
- /* Modify the word in the cache. */
- db->data[(addr>>2)&3] = data;
-
- /* Send the changed word. */
- remote_write_bytes (addr, &data, 4);
+ return val;
+#else
+ return memory_insert_breakpoint (addr, contents_cache);
+#endif /* REMOTE_BREAKPOINT */
}
-/* Initialize the data cache. */
-
-dcache_init ()
+static int
+remote_remove_breakpoint (addr, contents_cache)
+ CORE_ADDR addr;
+ char *contents_cache;
{
- register i;
- register struct dcache_block *db;
-
- db = (struct dcache_block *) xmalloc (sizeof (struct dcache_block) *
- DCACHE_SIZE);
- dcache_free.next = dcache_free.last = &dcache_free;
- dcache_valid.next = dcache_valid.last = &dcache_valid;
- for (i=0;i<DCACHE_SIZE;i++,db++)
- insque (db, &dcache_free);
+#ifdef REMOTE_BREAKPOINT
+ return target_write_memory (addr, contents_cache, sizeof big_break_insn);
+#else
+ return memory_remove_breakpoint (addr, contents_cache);
+#endif /* REMOTE_BREAKPOINT */
}
-#endif /* 0 */
-
+\f
/* Define the target subroutine names */
-struct target_ops remote_ops = {
+static struct target_ops remote_ops =
+{
"remote", /* to_shortname */
"Remote serial target in gdb-specific protocol", /* to_longname */
"Use a remote computer via a serial line, using a gdb-specific protocol.\n\
remote_fetch_registers, /* to_fetch_registers */
remote_store_registers, /* to_store_registers */
remote_prepare_to_store, /* to_prepare_to_store */
- NULL, /* to_convert_to_virtual */
- NULL, /* to_convert_from_virtual */
remote_xfer_memory, /* to_xfer_memory */
remote_files_info, /* to_files_info */
- NULL, /* to_insert_breakpoint */
- NULL, /* to_remove_breakpoint */
+ remote_insert_breakpoint, /* to_insert_breakpoint */
+ remote_remove_breakpoint, /* to_remove_breakpoint */
NULL, /* to_terminal_init */
NULL, /* to_terminal_inferior */
NULL, /* to_terminal_ours_for_output */
NULL, /* to_terminal_ours */
NULL, /* to_terminal_info */
- NULL, /* to_kill */
- NULL, /* to_load */
+ remote_kill, /* to_kill */
+ generic_load, /* to_load */
NULL, /* to_lookup_symbol */
NULL, /* to_create_inferior */
- NULL, /* to_mourn_inferior */
+ remote_mourn, /* to_mourn_inferior */
+ 0, /* to_can_run */
+ 0, /* to_notice_signals */
+ remote_thread_alive, /* to_thread_alive */
+ 0, /* to_stop */
process_stratum, /* to_stratum */
NULL, /* to_next */
1, /* to_has_all_memory */
OPS_MAGIC /* to_magic */
};
+static struct target_ops extended_remote_ops =
+{
+ "extended-remote", /* to_shortname */
+ "Extended remote serial target in gdb-specific protocol",/* to_longname */
+ "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
+Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
+ extended_remote_open, /* to_open */
+ remote_close, /* to_close */
+ NULL, /* to_attach */
+ remote_detach, /* to_detach */
+ remote_resume, /* to_resume */
+ remote_wait, /* to_wait */
+ remote_fetch_registers, /* to_fetch_registers */
+ remote_store_registers, /* to_store_registers */
+ remote_prepare_to_store, /* to_prepare_to_store */
+ remote_xfer_memory, /* to_xfer_memory */
+ remote_files_info, /* to_files_info */
+
+ remote_insert_breakpoint, /* to_insert_breakpoint */
+ remote_remove_breakpoint, /* to_remove_breakpoint */
+
+ NULL, /* to_terminal_init */
+ NULL, /* to_terminal_inferior */
+ NULL, /* to_terminal_ours_for_output */
+ NULL, /* to_terminal_ours */
+ NULL, /* to_terminal_info */
+ remote_kill, /* to_kill */
+ generic_load, /* to_load */
+ NULL, /* to_lookup_symbol */
+ extended_remote_create_inferior,/* to_create_inferior */
+ extended_remote_mourn, /* to_mourn_inferior */
+ 0, /* to_can_run */
+ 0, /* to_notice_signals */
+ remote_thread_alive, /* to_thread_alive */
+ 0, /* to_stop */
+ process_stratum, /* to_stratum */
+ NULL, /* to_next */
+ 1, /* to_has_all_memory */
+ 1, /* to_has_memory */
+ 1, /* to_has_stack */
+ 1, /* to_has_registers */
+ 1, /* to_has_execution */
+ NULL, /* sections */
+ NULL, /* sections_end */
+ OPS_MAGIC /* to_magic */
+};
+
+/* Some targets are only capable of doing downloads, and afterwards they switch
+ to the remote serial protocol. This function provides a clean way to get
+ from the download target to the remote target. It's basically just a
+ wrapper so that we don't have to expose any of the internal workings of
+ remote.c.
+
+ Prior to calling this routine, you should shutdown the current target code,
+ else you will get the "A program is being debugged already..." message.
+ Usually a call to pop_target() suffices.
+*/
+
+void
+push_remote_target (name, from_tty)
+ char *name;
+ int from_tty;
+{
+ printf_filtered ("Switching to remote protocol\n");
+ remote_open (name, from_tty);
+}
+
void
_initialize_remote ()
{
add_target (&remote_ops);
-
- add_show_from_set (
- add_set_cmd ("remotedebug", no_class, var_boolean, (char *)&kiodebug,
- "Set debugging of remote serial I/O.\n\
-When enabled, each packet sent or received with the remote target\n\
-is displayed.", &setlist),
- &showlist);
+ add_target (&extended_remote_ops);
+
+ add_show_from_set (add_set_cmd ("remotetimeout", no_class,
+ var_integer, (char *)&remote_timeout,
+ "Set timeout value for remote read.\n", &setlist),
+ &showlist);
+
+ add_show_from_set (add_set_cmd ("remotebreak", no_class,
+ var_integer, (char *)&remote_break,
+ "Set whether to send break if interrupted.\n", &setlist),
+ &showlist);
+
+ add_show_from_set (add_set_cmd ("remotewritesize", no_class,
+ var_integer, (char *)&remote_write_size,
+ "Set the maximum number of bytes in each memory write packet.\n", &setlist),
+ &showlist);
}
-
-#endif
projects / deliverable / binutils-gdb.git / blobdiff