-/* Memory-access and commands for inferior process, for GDB.
- Copyright (C) 1988, 1989 Free Software Foundation, Inc.
+/* Remote target communications for serial-line targets in custom GDB protocol
+ Copyright 1988, 1991, 1992, 1993 Free Software Foundation, Inc.
This file is part of GDB.
-GDB 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
-the Free Software Foundation; either version 1, or (at your option)
-any later version.
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
-GDB 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
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
-along with GDB; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* Remote communication protocol.
All values are encoded in ascii hex digits.
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
*/
#include "defs.h"
-#include "param.h"
+#include <string.h>
+#include <fcntl.h>
#include "frame.h"
#include "inferior.h"
-
+#include "symfile.h"
+#include "target.h"
#include "wait.h"
+#include "terminal.h"
+#include "gdbcmd.h"
+#if !defined(DONT_USE_REMOTE)
#ifdef USG
#include <sys/types.h>
-#include <fcntl.h>
#endif
-#include <stdio.h>
#include <signal.h>
-#include <sys/ioctl.h>
-#include <sys/file.h>
-
-#ifdef HAVE_TERMIO
-#include <termio.h>
-#undef TIOCGETP
-#define TIOCGETP TCGETA
-#undef TIOCSETN
-#define TIOCSETN TCSETA
-#undef TIOCSETP
-#define TIOCSETP TCSETAF
-#define TERMINAL struct termio
-#else
-#include <sgtty.h>
-#define TERMINAL struct sgttyb
-#endif
+#include "serial.h"
+
+/* Prototypes for local functions */
+
+static void
+remote_write_bytes PARAMS ((CORE_ADDR, char *, int));
+
+static void
+remote_read_bytes PARAMS ((CORE_ADDR, char *, int));
+
+static void
+remote_files_info PARAMS ((struct target_ops *));
+
+static int
+remote_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *));
+
+static void
+remote_prepare_to_store PARAMS ((void));
+
+static void
+remote_fetch_registers PARAMS ((int));
-static int kiodebug;
-static int timeout = 5;
+static void
+remote_resume PARAMS ((int, int));
+
+static int
+remote_start_remote PARAMS ((char *));
+
+static void
+remote_open PARAMS ((char *, int));
+
+static void
+remote_close PARAMS ((int));
+
+static void
+remote_store_registers PARAMS ((int));
+
+static void
+getpkt PARAMS ((char *, int));
+
+static void
+putpkt PARAMS ((char *));
+
+static void
+remote_send PARAMS ((char *));
+
+static int
+readchar PARAMS ((void));
+
+static int
+remote_wait PARAMS ((WAITTYPE *));
+
+static int
+tohex PARAMS ((int));
+
+static int
+fromhex PARAMS ((int));
+
+static void
+remote_detach PARAMS ((char *, int));
+
+extern struct target_ops remote_ops; /* Forward decl */
+
+static int kiodebug = 0;
+/* 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. */
+static int timeout = 2;
#if 0
int icache;
/* Descriptor for I/O to remote machine. Initialize it to -1 so that
remote_open knows that we don't have a file open when the program
starts. */
-int remote_desc = -1;
+serial_t remote_desc = NULL;
-#define PBUFSIZ 400
+#define PBUFSIZ 1024
/* 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)
-static void remote_send ();
-static void putpkt ();
-static void getpkt ();
-#if 0
-static void dcache_flush ();
+/* Round up PBUFSIZ to hold all the registers, at least. */
+#if REGISTER_BYTES > MAXBUFBYTES
+#undef PBUFSIZ
+#define PBUFSIZ (REGISTER_BYTES * 2 + 32)
#endif
-
\f
-/* Called when SIGALRM signal sent due to alarm() timeout. */
-#ifndef HAVE_TERMIO
-void
-remote_timer ()
+/* Clean up connection to a remote debugger. */
+
+/* ARGSUSED */
+static void
+remote_close (quitting)
+ int quitting;
{
- if (kiodebug)
- printf ("remote_timer called\n");
+ if (remote_desc)
+ SERIAL_CLOSE (remote_desc);
+ remote_desc = NULL;
+}
- alarm (timeout);
+/* Stub for catch_errors. */
+
+static int
+remote_start_remote (dummy)
+ char *dummy;
+{
+ /* Ack any packet which the remote side has already sent. */
+ SERIAL_WRITE (remote_desc, "+\r", 2);
+ putpkt ("?"); /* initiate a query from remote machine */
+
+ start_remote (); /* Initialize gdb process mechanisms */
+ return 1;
}
-#endif
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
-void
+static void
remote_open (name, from_tty)
char *name;
int from_tty;
{
- TERMINAL sg;
+ if (name == 0)
+ 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);
- if (remote_desc >= 0)
- close (remote_desc);
+ unpush_target (&remote_ops);
- remote_debugging = 0;
#if 0
dcache_init ();
#endif
- remote_desc = open (name, O_RDWR);
- if (remote_desc < 0)
+ remote_desc = SERIAL_OPEN (name);
+ if (!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);
-#else
- sg.sg_flags = RAW;
-#endif
- ioctl (remote_desc, TIOCSETP, &sg);
+ if (baud_rate)
+ {
+ int rate;
+
+ if (sscanf (baud_rate, "%d", &rate) == 1)
+ if (SERIAL_SETBAUDRATE (remote_desc, rate))
+ {
+ SERIAL_CLOSE (remote_desc);
+ perror_with_name (name);
+ }
+ }
- if (from_tty)
- printf ("Remote debugging using %s\n", name);
- remote_debugging = 1;
-
-#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
+ SERIAL_RAW (remote_desc);
- /* Set up read timeout timer. */
- if ((void (*)) signal (SIGALRM, remote_timer) == (void (*)) -1)
- perror ("remote_open: error in signal");
-#endif
+ if (from_tty)
+ {
+ puts_filtered ("Remote debugging using ");
+ puts_filtered (name);
+ puts_filtered ("\n");
+ }
+ push_target (&remote_ops); /* Switch to using remote target now */
- putpkt ("?"); /* initiate a query from remote machine */
+ /* Start the remote connection; if error (0), discard this target. */
+ immediate_quit++; /* Allow user to interrupt it */
+ if (!catch_errors (remote_start_remote, (char *)0,
+ "Couldn't establish connection to remote target\n"))
+ pop_target();
}
-/* Close the open connection to the remote debugger.
+/* 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. */
-void
-remote_close (from_tty)
+
+static void
+remote_detach (args, from_tty)
+ char *args;
int from_tty;
{
- if (!remote_debugging)
- error ("Can't close remote connection: not debugging remotely.");
+ if (args)
+ error ("Argument given to \"detach\" when remotely debugging.");
- close (remote_desc); /* This should never be called if
- there isn't something valid in
- remote_desc. */
-
- /* Do not try to close remote_desc again, later in the program. */
- remote_desc = -1;
-
+ pop_target ();
if (from_tty)
- printf ("Ending remote debugging\n");
-
- remote_debugging = 0;
+ puts_filtered ("Ending remote debugging.\n");
}
-
+
/* Convert hex digit A to a number. */
static int
return a - 'a' + 10;
else
error ("Reply contains invalid hex digit");
+ return -1;
}
/* Convert number NIB to a hex digit. */
\f
/* Tell the remote machine to resume. */
-int
-remote_resume (step, signal)
- int step, signal;
+static void
+remote_resume (step, siggnal)
+ int step, siggnal;
{
char buf[PBUFSIZ];
+ if (siggnal)
+ {
+ char *name;
+ target_terminal_ours_for_output ();
+ printf_filtered ("Can't send signals to a remote system. ");
+ name = strsigno (siggnal);
+ if (name)
+ printf_filtered (name);
+ else
+ printf_filtered ("Signal %d", siggnal);
+ printf_filtered (" not sent.\n");
+ target_terminal_inferior ();
+ }
+
#if 0
dcache_flush ();
#endif
putpkt (buf);
}
+\f
+static void remote_interrupt_twice PARAMS ((int));
+static void (*ofunc)();
+
+/* Send ^C to target to halt it. Target will respond, and send us a
+ packet. */
+
+void remote_interrupt(signo)
+ int signo;
+{
+ /* If this doesn't work, try more severe steps. */
+ signal (signo, remote_interrupt_twice);
+
+ if (kiodebug)
+ printf ("remote_interrupt called\n");
+
+ SERIAL_WRITE (remote_desc, "\003", 1); /* Send a ^C */
+}
+
+/* The user typed ^C twice. */
+static void
+remote_interrupt_twice (signo)
+ int signo;
+{
+ signal (signo, ofunc);
+
+ 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 ();
+ }
+ else
+ {
+ signal (signo, remote_interrupt);
+ target_terminal_inferior ();
+ }
+}
/* Wait until the remote machine stops, then return,
- storing status in STATUS just as `wait' would. */
+ storing status in STATUS just as `wait' would.
+ Returns "pid" (though it's not clear what, if anything, that
+ means in the case of this target). */
-int
+static int
remote_wait (status)
WAITTYPE *status;
{
unsigned char buf[PBUFSIZ];
+ unsigned char *p;
+ int i;
+ long regno;
+ char regs[MAX_REGISTER_RAW_SIZE];
WSETEXIT ((*status), 0);
- getpkt (buf);
+
+ ofunc = (void (*)()) signal (SIGINT, remote_interrupt);
+ getpkt ((char *) buf, 1);
+ signal (SIGINT, ofunc);
+
if (buf[0] == 'E')
error ("Remote failure reply: %s", buf);
- if (buf[0] != 'S')
+ if (buf[0] == 'T')
+ {
+ /* 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)
+ {
+ regno = strtol (p, &p, 16); /* Read the register number */
+
+ if (*p++ != ':'
+ || regno >= NUM_REGS)
+ error ("Remote sent bad register number %s", buf);
+
+ for (i = 0; i < REGISTER_RAW_SIZE (regno); i++)
+ {
+ 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;
+ }
+
+ if (*p++ != ';')
+ error("Remote register badly formatted: %s", buf);
+
+ supply_register (regno, regs);
+ }
+ }
+ else if (buf[0] != 'S')
error ("Invalid remote reply: %s", buf);
+
WSETSTOP ((*status), (((fromhex (buf[1])) << 4) + (fromhex (buf[2]))));
+
+ return 0;
}
/* Read the remote registers into the block REGS. */
-
-void
-remote_fetch_registers (regs)
- char *regs;
+/* Currently we just read all the registers, so we don't use regno. */
+/* ARGSUSED */
+static void
+remote_fetch_registers (regno)
+ int regno;
{
char buf[PBUFSIZ];
int i;
char *p;
+ char regs[REGISTER_BYTES];
sprintf (buf, "g");
remote_send (buf);
- /* Reply describes registers byte by byte,
- each byte encoded as two hex characters. */
+ /* 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++)
regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
+ for (i = 0; i < NUM_REGS; i++)
+ supply_register (i, ®s[REGISTER_BYTE(i)]);
}
-/* Store the remote registers from the contents of the block REGS. */
+/* Prepare to store registers. Since we send them all, we have to
+ read out the ones we don't want to change first. */
-void
-remote_store_registers (regs)
- char *regs;
+static void
+remote_prepare_to_store ()
+{
+ /* 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. */
+
+/* ARGSUSED */
+static void
+remote_store_registers (regno)
+ int regno;
{
char buf[PBUFSIZ];
int i;
p = buf + 1;
for (i = 0; i < REGISTER_BYTES; i++)
{
- *p++ = tohex ((regs[i] >> 4) & 0xf);
- *p++ = tohex (regs[i] & 0xf);
+ *p++ = tohex ((registers[i] >> 4) & 0xf);
+ *p++ = tohex (registers[i] & 0xf);
}
*p = '\0';
{
dcache_poke (addr, word);
}
-#else /* not 0 */
-void remote_fetch_word (addr)
- CORE_ADDR addr;
-{
- error ("Internal error: remote_fetch_word is obsolete.\n");
-}
-void remote_store_word (addr)
- CORE_ADDR addr;
-{
- error ("Internal error: remote_store_word is obsolete.\n");
-}
-#endif /* not 0 */
+#endif /* 0 */
\f
/* Write memory data directly to the remote machine.
This does not inform the data cache; the data cache uses this.
MYADDR is the address of the buffer in our space.
LEN is the number of bytes. */
-void
+static void
remote_write_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
char *myaddr;
sprintf (buf, "M%x,%x:", memaddr, len);
- /* Command describes registers byte by byte,
+ /* We send target system values byte by byte, in increasing byte addresses,
each byte encoded as two hex characters. */
p = buf + strlen (buf);
MYADDR is the address of the buffer in our space.
LEN is the number of bytes. */
-void
+static void
remote_read_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
char *myaddr;
sprintf (buf, "m%x,%x", memaddr, len);
remote_send (buf);
- /* Reply describes registers byte by byte,
+ /* Reply describes memory byte by byte,
each byte encoded as two hex characters. */
p = buf;
}
}
\f
-/* Read LEN bytes from inferior memory at MEMADDR. Put the result
- at debugger address MYADDR. Returns errno value. */
-int
-remote_read_inferior_memory(memaddr, myaddr, len)
+/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
+ to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
+ nonzero. Returns length of data written or read; 0 for error. */
+
+/* ARGSUSED */
+static int
+remote_xfer_memory(memaddr, myaddr, len, should_write, target)
CORE_ADDR memaddr;
char *myaddr;
int len;
+ int should_write;
+ struct target_ops *target; /* ignored */
{
+ int origlen = len;
int xfersize;
while (len > 0)
{
else
xfersize = len;
- remote_read_bytes (memaddr, myaddr, xfersize);
+ if (should_write)
+ remote_write_bytes(memaddr, myaddr, xfersize);
+ else
+ remote_read_bytes (memaddr, myaddr, xfersize);
memaddr += xfersize;
myaddr += xfersize;
len -= xfersize;
}
- return 0; /* no error */
+ return origlen; /* no error possible */
}
-/* Copy LEN bytes of data from debugger memory at MYADDR
- to inferior's memory at MEMADDR. Returns errno value. */
-int
-remote_write_inferior_memory (memaddr, myaddr, len)
- CORE_ADDR memaddr;
- char *myaddr;
- int len;
+static void
+remote_files_info (ignore)
+struct target_ops *ignore;
{
- int xfersize;
- while (len > 0)
- {
- if (len > MAXBUFBYTES)
- xfersize = MAXBUFBYTES;
- else
- xfersize = len;
-
- remote_write_bytes(memaddr, myaddr, xfersize);
-
- memaddr += xfersize;
- myaddr += xfersize;
- len -= xfersize;
- }
- return 0; /* no error */
+ puts_filtered ("Debugging a target over a serial line.\n");
}
\f
/*
*/
+/* Read a single character from the remote end, masking it down to 7 bits. */
+
static int
readchar ()
{
- char buf;
+ int ch;
- buf = '\0';
-#ifdef HAVE_TERMIO
- /* termio does the timeout for us. */
- read (remote_desc, &buf, 1);
-#else
- alarm (timeout);
- read (remote_desc, &buf, 1);
- alarm (0);
-#endif
+ ch = SERIAL_READCHAR (remote_desc, timeout);
+
+ if (ch < 0)
+ return ch;
- return buf & 0x7f;
+ return ch & 0x7f;
}
/* Send the command in BUF to the remote machine,
remote_send (buf)
char *buf;
{
- int i;
+
putpkt (buf);
- getpkt (buf);
+ getpkt (buf, 0);
if (buf[0] == 'E')
error ("Remote failure reply: %s", buf);
{
int i;
unsigned char csum = 0;
- char buf2[500];
- char buf3[1];
+ char buf2[PBUFSIZ];
int cnt = strlen (buf);
- char ch;
+ int ch;
char *p;
/* Copy the packet into buffer BUF2, encapsulating it
and giving it a checksum. */
+ if (cnt > sizeof(buf2) - 5) /* Prosanity check */
+ abort();
+
p = buf2;
*p++ = '$';
/* Send it over and over until we get a positive ack. */
- do {
- if (kiodebug)
- {
- *p = '\0';
- printf ("Sending packet: %s (%s)\n", buf2, buf);
- }
- write (remote_desc, buf2, p - buf2);
+ while (1)
+ {
+ if (kiodebug)
+ {
+ *p = '\0';
+ printf ("Sending packet: %s...", buf2); fflush(stdout);
+ }
+ if (SERIAL_WRITE (remote_desc, buf2, p - buf2))
+ perror_with_name ("putpkt: write failed");
- /* read until either a timeout occurs (\0) or '+' is read */
- do {
- ch = readchar ();
- } while ((ch != '+') && (ch != '\0'));
- } while (ch != '+');
+ /* read until either a timeout occurs (-2) or '+' is read */
+ while (1)
+ {
+ ch = readchar ();
+
+ switch (ch)
+ {
+ case '+':
+ if (kiodebug)
+ printf("Ack\n");
+ return;
+ case SERIAL_TIMEOUT:
+ break; /* Retransmit buffer */
+ case SERIAL_ERROR:
+ perror_with_name ("putpkt: couldn't read ACK");
+ case SERIAL_EOF:
+ error ("putpkt: EOF while trying to read ACK");
+ default:
+ if (kiodebug)
+ printf ("%02X %c ", ch&0xFF, ch);
+ continue;
+ }
+ break; /* Here to retransmit */
+ }
+ }
}
/* Read a packet from the remote machine, with error checking,
- and store it in BUF. */
+ 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)
+getpkt (buf, forever)
char *buf;
+ int forever;
{
char *bp;
unsigned char csum;
- int c;
+ int c = 0;
unsigned char c1, c2;
- extern kiodebug;
-
- /* allow immediate quit while reading from device, it could be hung */
- immediate_quit++;
+ int retries = 0;
+#define MAX_RETRIES 10
while (1)
{
+ /* 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. */
+
+ c = readchar();
+ if (c > 0 && c != '$')
+ continue;
+
+ if (c == SERIAL_TIMEOUT)
+ {
+ if (forever)
+ continue;
+ if (++retries >= MAX_RETRIES)
+ if (kiodebug) puts_filtered ("Timed out.\n");
+ goto out;
+ }
+
+ if (c == SERIAL_EOF)
+ error ("Remote connection closed");
+ if (c == SERIAL_ERROR)
+ perror_with_name ("Remote communication error");
+
/* Force csum to be zero here because of possible error retry. */
csum = 0;
-
- while ((c = readchar()) != '$');
-
bp = buf;
+
while (1)
{
c = readchar ();
+ if (c == SERIAL_TIMEOUT)
+ {
+ if (kiodebug)
+ puts_filtered ("Timeout in mid-packet, retrying\n");
+ goto whole; /* Start a new packet, count retries */
+ }
+ if (c == '$')
+ {
+ if (kiodebug)
+ puts_filtered ("Saw new packet start in middle of old one\n");
+ goto whole; /* Start a new packet, count retries */
+ }
if (c == '#')
break;
+ if (bp >= buf+PBUFSIZ-1)
+ {
+ *bp = '\0';
+ puts_filtered ("Remote packet too long: ");
+ puts_filtered (buf);
+ puts_filtered ("\n");
+ goto whole;
+ }
*bp++ = c;
csum += c;
}
c2 = fromhex (readchar ());
if ((csum & 0xff) == (c1 << 4) + c2)
break;
- printf ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n",
- (c1 << 4) + c2, csum & 0xff, buf);
- write (remote_desc, "-", 1);
+ printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
+ (c1 << 4) + c2, csum & 0xff);
+ puts_filtered (buf);
+ puts_filtered ("\n");
+
+ /* Try the whole thing again. */
+whole:
+ if (++retries < MAX_RETRIES)
+ {
+ SERIAL_WRITE (remote_desc, "-", 1);
+ }
+ else
+ {
+ printf ("Ignoring packet error, continuing...\n");
+ break;
+ }
}
- immediate_quit--;
+out:
- write (remote_desc, "+", 1);
+ SERIAL_WRITE (remote_desc, "+", 1);
if (kiodebug)
- fprintf (stderr,"Packet received :%s\n", buf);
+ fprintf (stderr,"Packet received: %s\n", buf);
}
\f
/* The data cache leads to incorrect results because it doesn't know about
insque (db, &dcache_free);
}
#endif /* 0 */
+\f
+static void
+remote_kill ()
+{
+ putpkt ("k");
+ /* 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 ();
+}
+
+static void
+remote_mourn ()
+{
+ unpush_target (&remote_ops);
+ generic_mourn_inferior ();
+}
+\f
+/* Define the target subroutine names */
+
+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\
+Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
+ 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 */
+ NULL, /* to_insert_breakpoint */
+ NULL, /* 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 */
+ NULL, /* to_create_inferior */
+ remote_mourn, /* to_mourn_inferior */
+ 0, /* to_can_run */
+ 0, /* to_notice_signals */
+ 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 */
+};
+
+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);
+}
+
+#endif