1991-04-05 09:01:15 +00:00
|
|
|
|
/* THIS FILE HAS NOT HAD ITS COPYRIGHT CHECKED...FSF SHOULD NOT
|
|
|
|
|
DISTRIBUTE IT UNTIL THIS HAPPENS. */
|
|
|
|
|
|
|
|
|
|
/* Memory-access and commands for inferior process, for GDB.
|
|
|
|
|
*/
|
|
|
|
|
|
1992-03-03 23:26:26 +00:00
|
|
|
|
#include "defs.h"
|
1991-04-05 09:01:15 +00:00
|
|
|
|
#include <sys/errno.h>
|
|
|
|
|
#include <setjmp.h>
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "value.h"
|
|
|
|
|
#include "inferior.h"
|
|
|
|
|
#include "symtab.h"
|
|
|
|
|
|
|
|
|
|
#undef WSTOPSIG
|
|
|
|
|
#undef WTERMSIG
|
|
|
|
|
#include "wait.h"
|
|
|
|
|
|
|
|
|
|
#ifdef USG
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include <signal.h>
|
|
|
|
|
#include <sys/file.h>
|
|
|
|
|
|
|
|
|
|
#include <termios.h>
|
|
|
|
|
#define TERMINAL struct termios
|
|
|
|
|
|
|
|
|
|
#define LONGTIMEOUT 5
|
|
|
|
|
#define SHORTTIMEOUT 1
|
|
|
|
|
|
|
|
|
|
#define KD_MINUTAE 1
|
|
|
|
|
#define KD_LINEDISCIPLINE 2
|
|
|
|
|
#define KD_RETRY 4
|
|
|
|
|
#define KD_BLOCKTRANSFER 8
|
|
|
|
|
|
|
|
|
|
#ifndef STDIN
|
|
|
|
|
#define STDIN 0
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#define GL_READING 0 /* get line is reading data */
|
|
|
|
|
#define GL_OK 1 /* Getline saw the "ok" string */
|
|
|
|
|
#define GL_SUCCESS 2 /* Get line got data */
|
|
|
|
|
#define GL_TIMEOUT 3 /* Get line timed out */
|
|
|
|
|
#define GL_OVERRUN 4 /* Get line filled up the buffer */
|
|
|
|
|
#define GL_EXCEPTION 5 /* Get line saw "Exception" */
|
|
|
|
|
#define GL_PROMLINE 6 /* Get line saw prom specific info */
|
|
|
|
|
#define GL_BLANKLINE 7 /* Get line saw a blank line */
|
|
|
|
|
|
|
|
|
|
static int kiodebug /* = KD_RETRY | KD_BLOCKTRANSFER */;
|
|
|
|
|
|
|
|
|
|
static CORE_ADDR remote_pc = 0;
|
|
|
|
|
static CORE_ADDR remote_next_pc = 0;
|
|
|
|
|
static CORE_ADDR remove_thisbp_next_pc = 0;
|
|
|
|
|
static CORE_ADDR remove_thisbp_target = 0;
|
|
|
|
|
|
|
|
|
|
enum showDrainage {DONTSHOW , SHOW} ;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
|
|
int dontskipcrs = 0;
|
|
|
|
|
|
|
|
|
|
#define PBUFSIZ 400
|
|
|
|
|
|
|
|
|
|
unsigned char ignorebuf[PBUFSIZ];
|
|
|
|
|
#define IGNORE &ignorebuf[0]
|
|
|
|
|
|
|
|
|
|
/* 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 int getpkt ();
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Open a connection to a remote debugger.
|
|
|
|
|
NAME is the filename used for communication. */
|
|
|
|
|
CORE_ADDR breakpoint_regs_addr;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
remote_open (name, from_tty)
|
|
|
|
|
char *name;
|
|
|
|
|
int from_tty;
|
|
|
|
|
{
|
|
|
|
|
extern int frame_file_full_name;
|
|
|
|
|
unsigned char buf[PBUFSIZ];
|
|
|
|
|
TERMINAL sg;
|
|
|
|
|
|
|
|
|
|
remote_debugging = 0;
|
|
|
|
|
|
|
|
|
|
if (remote_desc >= 0)
|
|
|
|
|
close (remote_desc);
|
|
|
|
|
|
|
|
|
|
breakpoint_regs_addr = parse_and_eval_address("&breakpoint_regs");
|
|
|
|
|
|
|
|
|
|
dontskipcrs = !frame_file_full_name; /* if we are running inside of
|
|
|
|
|
emacs, this will be true.
|
|
|
|
|
then skip carriage returns */
|
|
|
|
|
|
|
|
|
|
remote_desc = open (name, O_RDWR);
|
|
|
|
|
if (remote_desc < 0)
|
|
|
|
|
perror_with_name (name);
|
|
|
|
|
|
|
|
|
|
setup_remote();
|
|
|
|
|
|
|
|
|
|
if (from_tty)
|
|
|
|
|
printf ("Remote debugging using %s\n", name);
|
|
|
|
|
remote_debugging = 1;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
static char *boot_cmd = 0;
|
|
|
|
|
|
|
|
|
|
static print_boot_cmd()
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "boot command set to be \"%s\"\n", boot_cmd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
remote_start()
|
|
|
|
|
{
|
|
|
|
|
WAITTYPE ignoredWaitType;
|
|
|
|
|
|
|
|
|
|
if (boot_cmd)
|
|
|
|
|
{
|
|
|
|
|
sendbreak();
|
|
|
|
|
remote_wait (&ignoredWaitType);
|
|
|
|
|
putpkt ("reset");
|
|
|
|
|
sleep(10);
|
|
|
|
|
sendbreak();
|
|
|
|
|
remote_wait (&ignoredWaitType);
|
|
|
|
|
sleep(10);
|
|
|
|
|
print_boot_cmd();
|
|
|
|
|
putpkt(boot_cmd);
|
|
|
|
|
fprintf(stderr, "rgdb and nucleus synchronized, booting....\n");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error("The boot command is null. Cannot start the remote kernel/nucleus");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
int from_tty;
|
|
|
|
|
{
|
|
|
|
|
if (!remote_debugging)
|
|
|
|
|
error ("Can't close remote connection: not debugging remotely.");
|
|
|
|
|
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
|
|
if (from_tty)
|
|
|
|
|
printf ("Ending remote debugging\n");
|
|
|
|
|
|
|
|
|
|
remote_debugging = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Convert hex digit A to a number. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
fromhex (a)
|
|
|
|
|
int a;
|
|
|
|
|
{
|
|
|
|
|
if (a >= '0' && a <= '9')
|
|
|
|
|
return a - '0';
|
|
|
|
|
else if (a >= 'a' && a <= 'f')
|
|
|
|
|
return a - 'a' + 10;
|
|
|
|
|
else
|
|
|
|
|
error ("Reply contains invalid hex digit");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Convert number NIB to a hex digit. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
tohex (nib)
|
|
|
|
|
int nib;
|
|
|
|
|
{
|
|
|
|
|
if (nib < 10)
|
|
|
|
|
return '0'+nib;
|
|
|
|
|
else
|
|
|
|
|
return 'a'+nib-10;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Tell the remote machine to resume. */
|
|
|
|
|
|
|
|
|
|
extern int one_stepped; /* From machine dependent code */
|
|
|
|
|
static int remote_set_one_stepped;
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
remote_resume (step, signal)
|
|
|
|
|
int step, signal;
|
|
|
|
|
{
|
|
|
|
|
if (step)
|
|
|
|
|
{
|
|
|
|
|
remote_single_step();
|
|
|
|
|
}
|
|
|
|
|
remote_set_one_stepped = step;
|
|
|
|
|
putpkt("go");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Wait until the remote machine stops, then return,
|
|
|
|
|
storing status in STATUS just as `wait' would. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
remote_wait (status)
|
|
|
|
|
WAITTYPE *status;
|
|
|
|
|
{
|
|
|
|
|
char last, this;
|
|
|
|
|
int pend, saveTheOh = 0;
|
|
|
|
|
|
|
|
|
|
user_terminal_raw();
|
|
|
|
|
|
|
|
|
|
WSETEXIT ((*status), 0177);
|
|
|
|
|
last = this = 0;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
char buf[PBUFSIZ];
|
|
|
|
|
int readUser, readProm, state;
|
|
|
|
|
|
|
|
|
|
doselect(&readUser, &readProm);
|
|
|
|
|
if (readProm)
|
|
|
|
|
{
|
|
|
|
|
switch (state = getline(buf, PBUFSIZ, SHORTTIMEOUT))
|
|
|
|
|
{
|
|
|
|
|
case GL_BLANKLINE:
|
|
|
|
|
if (remote_set_one_stepped)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
/* fall through */
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
case GL_READING:
|
|
|
|
|
case GL_SUCCESS:
|
|
|
|
|
case GL_OVERRUN:
|
|
|
|
|
case GL_TIMEOUT:
|
|
|
|
|
if (kiodebug & KD_LINEDISCIPLINE)
|
|
|
|
|
fprintf(stderr, "%d<%s>\n", state, buf);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "%s", buf);
|
|
|
|
|
fflush(stderr);
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
case GL_OK:
|
|
|
|
|
remote_cleanup_after_stop();
|
|
|
|
|
WSETSTOP ((*status), SIGTRAP);
|
|
|
|
|
return;
|
|
|
|
|
case GL_PROMLINE:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (readUser)
|
|
|
|
|
shuffleFromUserToProm();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
static TERMINAL userterminal;
|
|
|
|
|
|
|
|
|
|
user_terminal_restore()
|
|
|
|
|
{
|
|
|
|
|
#if 0
|
|
|
|
|
int in_desc = fileno (stdin);
|
|
|
|
|
ioctl (in_desc, TCSETS, &userterminal);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
static void set_term_raw();
|
|
|
|
|
|
|
|
|
|
user_terminal_raw()
|
|
|
|
|
{
|
|
|
|
|
#if 0
|
|
|
|
|
TERMINAL tempterminal;
|
|
|
|
|
int in_desc = fileno (stdin);
|
|
|
|
|
ioctl (in_desc, TCGETS, &userterminal);
|
|
|
|
|
tempterminal = userterminal;
|
|
|
|
|
|
|
|
|
|
tempterminal.c_lflag &= ~(ICANON|ISIG|IEXTEN);
|
|
|
|
|
tempterminal.c_cc[VMIN] = 1;
|
|
|
|
|
tempterminal.c_cc[VTIME] = 0;
|
|
|
|
|
tempterminal.c_iflag &= ~(INPCK|IXON|IXOFF);
|
|
|
|
|
tempterminal.c_oflag = 0;
|
|
|
|
|
|
|
|
|
|
ioctl (in_desc, TCSETS, &tempterminal);
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
doselect(pReadUser, pReadProm)
|
|
|
|
|
int *pReadUser, *pReadProm;
|
|
|
|
|
{
|
|
|
|
|
extern FILE *instream;
|
|
|
|
|
int in_desc = fileno (stdin);
|
|
|
|
|
int instreammask = 1 << in_desc;
|
|
|
|
|
int remotemask = 1 << remote_desc;
|
|
|
|
|
int rfds = instreammask | remotemask;
|
|
|
|
|
|
|
|
|
|
select (32, &rfds, 0, 0, (struct timeval *) 0); /* 0 = Block indefinitely */
|
|
|
|
|
*pReadUser = (rfds & instreammask) == instreammask;
|
|
|
|
|
*pReadProm = (rfds & remotemask) == remotemask;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Read the remote registers into the block pRegisters.
|
|
|
|
|
implementation copied largely from fetch_inferior_registers ()
|
|
|
|
|
in sparc-dep.c */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
remote_fetch_registers(ignored)
|
|
|
|
|
int *ignored;
|
|
|
|
|
{
|
|
|
|
|
struct regs inferior_registers;
|
|
|
|
|
extern char registers[];
|
|
|
|
|
CORE_ADDR breakpoint_regs_target;
|
|
|
|
|
|
|
|
|
|
if (breakpoint_regs_addr == 0)
|
|
|
|
|
{
|
|
|
|
|
error("no address for breakpoint_regs\n");
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
remote_read_inferior_memory(breakpoint_regs_addr, &breakpoint_regs_target,
|
|
|
|
|
sizeof(breakpoint_regs_target));
|
|
|
|
|
|
|
|
|
|
bzero(registers, REGISTER_BYTES);
|
|
|
|
|
registers[REGISTER_BYTE (0)] = 0;
|
|
|
|
|
|
|
|
|
|
if (breakpoint_regs_target)
|
|
|
|
|
{
|
|
|
|
|
remote_read_inferior_memory(breakpoint_regs_target, &inferior_registers,
|
|
|
|
|
sizeof(inferior_registers));
|
|
|
|
|
registers[REGISTER_BYTE (0)] = 0;
|
|
|
|
|
bcopy (&inferior_registers.r_g1, ®isters[REGISTER_BYTE (1)], 15 * 4);
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps;
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc;
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (NPC_REGNUM)] = inferior_registers.r_npc;
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y;
|
|
|
|
|
remote_pc = inferior_registers.r_pc;
|
|
|
|
|
remote_next_pc = inferior_registers.r_npc;
|
|
|
|
|
remote_read_inferior_memory (inferior_registers.r_sp,
|
|
|
|
|
®isters[REGISTER_BYTE (16)],
|
|
|
|
|
16*4);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
error("breakpoint_regs == 0\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
remote_write_bytes (memaddr, myaddr, len)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
unsigned char *myaddr;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
char buf[PBUFSIZ];
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
/* Command describes registers byte by byte,
|
|
|
|
|
each byte encoded as two hex characters. */
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
|
{
|
|
|
|
|
sprintf(buf, "%x %x c!", myaddr[i], memaddr + i);
|
|
|
|
|
remote_send (buf, buf);
|
|
|
|
|
if (strstr(buf, "Exception"))
|
|
|
|
|
{
|
|
|
|
|
return EFAULT;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
{
|
|
|
|
|
int xfersize;
|
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
|
|
while (len > 0)
|
|
|
|
|
{
|
|
|
|
|
if (len > MAXBUFBYTES)
|
|
|
|
|
xfersize = MAXBUFBYTES;
|
|
|
|
|
else
|
|
|
|
|
xfersize = len;
|
|
|
|
|
|
|
|
|
|
retval = remote_write_bytes(memaddr, myaddr, xfersize);
|
|
|
|
|
if (retval)
|
|
|
|
|
return retval; /* error */
|
|
|
|
|
|
|
|
|
|
memaddr += xfersize;
|
|
|
|
|
myaddr += xfersize;
|
|
|
|
|
len -= xfersize;
|
|
|
|
|
}
|
|
|
|
|
return 0; /* no error */
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* read a single character */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
readCharFromProm ()
|
|
|
|
|
{
|
|
|
|
|
char buf;
|
|
|
|
|
|
|
|
|
|
buf = '\0';
|
|
|
|
|
/* termio does the timeout for us. */
|
|
|
|
|
read (remote_desc, &buf, 1);
|
|
|
|
|
return buf & 0x7f;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Send the command in BUF to the remote machine,
|
|
|
|
|
and read the reply into BUF.
|
|
|
|
|
Report an error if we get an error reply. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
remote_send (buf, buf2)
|
|
|
|
|
char *buf, *buf2;
|
|
|
|
|
{
|
|
|
|
|
putpkt (buf);
|
|
|
|
|
getpkt (buf2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Send a single character out over the wire */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
putcharacter (ch)
|
|
|
|
|
char ch;
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
write(remote_desc, &ch, 1);
|
|
|
|
|
for (i = 0; i < 100; i++)
|
|
|
|
|
{
|
|
|
|
|
char nch = 0;
|
|
|
|
|
|
|
|
|
|
if (read (remote_desc, &nch, 1) == 0)
|
|
|
|
|
i++;
|
|
|
|
|
if ((ch == nch)
|
|
|
|
|
|| (ch == '\n' && nch == '\r')
|
|
|
|
|
|| (ch == '\r' && nch == '\n'))
|
|
|
|
|
return;
|
|
|
|
|
if (kiodebug & KD_MINUTAE)
|
|
|
|
|
fprintf (stderr, "Sent %c(%d) Received %c(%d)\n", ch, ch, nch, nch);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Send a packet to the remote machine, with error checking.
|
|
|
|
|
The data of the packet is in BUF. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
putpkt (buf)
|
|
|
|
|
char *buf;
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
int cnt = strlen (buf);
|
|
|
|
|
char ch;
|
|
|
|
|
|
|
|
|
|
if (kiodebug & KD_LINEDISCIPLINE)
|
|
|
|
|
fprintf(stderr, "putpkt(%s)\n", buf);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < cnt; i++)
|
|
|
|
|
putcharacter (buf[i]);
|
|
|
|
|
putcharacter ('\n');
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
jmp_buf getline_jmpbuf;
|
|
|
|
|
|
|
|
|
|
/* Read a line from the remote machine, and store it in BUF. */
|
|
|
|
|
getline_timer()
|
|
|
|
|
{
|
|
|
|
|
alarm(0);
|
|
|
|
|
|
|
|
|
|
if (kiodebug & KD_RETRY)
|
|
|
|
|
fprintf(stderr, "getline timed out\n");
|
|
|
|
|
longjmp(getline_jmpbuf, 1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
getline (buf, size, timeout)
|
|
|
|
|
char *buf;
|
|
|
|
|
int size, timeout;
|
|
|
|
|
{
|
|
|
|
|
int cnt = 0;
|
|
|
|
|
int state;
|
|
|
|
|
int isspace_state = 1;
|
|
|
|
|
|
|
|
|
|
if ((void (*)) signal (SIGALRM, getline_timer) == (void (*)) -1)
|
|
|
|
|
perror ("remote_open: error in signal");
|
|
|
|
|
|
|
|
|
|
--size; /* back it up one so that we can read */
|
|
|
|
|
|
|
|
|
|
state = GL_READING;
|
|
|
|
|
|
|
|
|
|
if (setjmp(getline_jmpbuf))
|
|
|
|
|
state = GL_TIMEOUT;
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
alarm (timeout);
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
char ch = readCharFromProm();
|
|
|
|
|
isspace_state = isspace_state && isspace(ch);
|
|
|
|
|
if (ch && (dontskipcrs || ch != '\r'))
|
|
|
|
|
{
|
|
|
|
|
buf[cnt++] = ch;
|
|
|
|
|
buf[cnt] = '\0';
|
|
|
|
|
}
|
|
|
|
|
if (kiodebug & KD_MINUTAE)
|
|
|
|
|
fprintf (stderr,"letter received :%c\n", buf[cnt - 1]);
|
|
|
|
|
if (cnt >= 2 && buf[cnt - 2] == 'o' && buf[cnt - 1] == 'k')
|
|
|
|
|
state = GL_OK;
|
|
|
|
|
else if (buf[cnt - 1] == '\n' )
|
|
|
|
|
state = isspace_state ? GL_BLANKLINE : GL_SUCCESS;
|
|
|
|
|
else if (cnt == size)
|
|
|
|
|
state = GL_OVERRUN;
|
|
|
|
|
else if (strstr(buf, "Type 'go' to resume"))
|
|
|
|
|
state = GL_PROMLINE;
|
|
|
|
|
else if (strstr(buf, "Type help for more information"))
|
|
|
|
|
state = GL_PROMLINE;
|
|
|
|
|
else if (strstr(buf, "Exception"))
|
|
|
|
|
state = GL_EXCEPTION;
|
|
|
|
|
}
|
|
|
|
|
while (state == GL_READING);
|
|
|
|
|
}
|
|
|
|
|
alarm (0);
|
|
|
|
|
|
|
|
|
|
if (kiodebug & KD_LINEDISCIPLINE)
|
|
|
|
|
fprintf (stderr,"Line received :%s\n", buf);
|
|
|
|
|
return state;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Read a packet from the remote machine, and store it in BUF. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
getpkt (buf)
|
|
|
|
|
char *buf;
|
|
|
|
|
{
|
|
|
|
|
int cnt = 0;
|
|
|
|
|
|
|
|
|
|
do
|
|
|
|
|
{
|
|
|
|
|
char ch = readCharFromProm();
|
|
|
|
|
if (ch)
|
|
|
|
|
buf[cnt++] = ch;
|
|
|
|
|
if (kiodebug & KD_MINUTAE)
|
|
|
|
|
fprintf (stderr,"letter received :%c\n", buf[cnt - 1]);
|
|
|
|
|
}
|
|
|
|
|
while (cnt < 2 ||
|
|
|
|
|
buf[cnt - 2] != 'o' &&
|
|
|
|
|
buf[cnt - 1] != 'k');
|
|
|
|
|
|
|
|
|
|
buf[cnt] = '\0';
|
|
|
|
|
if (kiodebug& KD_LINEDISCIPLINE)
|
|
|
|
|
fprintf (stderr,"Packet received :%s\n", buf);
|
|
|
|
|
return cnt;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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");
|
|
|
|
|
}
|
|
|
|
|
#include <termio.h>
|
|
|
|
|
|
|
|
|
|
draininput(showit)
|
|
|
|
|
enum showDrainage showit;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf[PBUFSIZ];
|
|
|
|
|
int cnt;
|
|
|
|
|
|
|
|
|
|
while ((cnt = read(remote_desc, buf, PBUFSIZ)) > 0)
|
|
|
|
|
{
|
|
|
|
|
buf[cnt] = 0;
|
|
|
|
|
if (kiodebug& KD_LINEDISCIPLINE)
|
|
|
|
|
fprintf (stderr,"Draining :%s\n", buf);
|
|
|
|
|
else
|
|
|
|
|
if (showit == SHOW)
|
|
|
|
|
fprintf (stderr,"%s", buf);
|
|
|
|
|
}
|
|
|
|
|
if (kiodebug& KD_LINEDISCIPLINE)
|
|
|
|
|
fprintf (stderr,"Drained\n");
|
|
|
|
|
}
|
|
|
|
|
sendbreak()
|
|
|
|
|
{
|
|
|
|
|
if (kiodebug & KD_RETRY)
|
|
|
|
|
fprintf (stderr,"rgdb sending break to target...\n");
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf (stderr,"=");
|
|
|
|
|
fflush(stderr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ioctl (remote_desc, TCSBRK, 0);
|
|
|
|
|
sleep(5);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* shuffle a character from the user to remote debugger */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
shuffleFromUserToProm()
|
|
|
|
|
{
|
|
|
|
|
char ch;
|
|
|
|
|
static int escape = 0;
|
|
|
|
|
|
|
|
|
|
extern FILE *instream;
|
|
|
|
|
|
|
|
|
|
ch = 0;
|
|
|
|
|
if (read(STDIN, &ch , 1) != 1 || ch == 0)
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (escape) {
|
|
|
|
|
if (ch == '#')
|
|
|
|
|
sendbreak();
|
|
|
|
|
else if (ch == '.')
|
|
|
|
|
{
|
|
|
|
|
while (ch != '\n')
|
|
|
|
|
read(STDIN, &ch , 1);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
else {
|
|
|
|
|
static char tilde = '~';
|
|
|
|
|
|
|
|
|
|
putcharacter(tilde);
|
|
|
|
|
putcharacter(ch);
|
|
|
|
|
}
|
|
|
|
|
escape = 0;
|
|
|
|
|
} else /* not escape */ {
|
|
|
|
|
if (ch == '~')
|
|
|
|
|
escape = 1;
|
|
|
|
|
else
|
|
|
|
|
putcharacter(ch);
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Tell the Prom put a breakpoint at memaddr */
|
|
|
|
|
remote_insert_breakpoint(memaddr)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
{
|
|
|
|
|
char buf[PBUFSIZ];
|
|
|
|
|
|
|
|
|
|
/* Command describes registers byte by byte,
|
|
|
|
|
each byte encoded as two hex characters. */
|
|
|
|
|
|
|
|
|
|
sprintf(buf, "%x +bp", memaddr);
|
|
|
|
|
remote_send(buf, buf);
|
|
|
|
|
if (strstr(buf, "Exception"))
|
|
|
|
|
{
|
|
|
|
|
return EFAULT;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Tell the Prom remove the the breakpoint at memaddr */
|
|
|
|
|
remote_remove_breakpoint(memaddr)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
{
|
|
|
|
|
char buf[PBUFSIZ];
|
|
|
|
|
|
|
|
|
|
/* Command describes registers byte by byte,
|
|
|
|
|
each byte encoded as two hex characters. */
|
|
|
|
|
|
|
|
|
|
sprintf(buf, "%x -bp", memaddr);
|
|
|
|
|
remote_send(buf, buf);
|
|
|
|
|
if (strstr(buf, "Exception"))
|
|
|
|
|
{
|
|
|
|
|
return EFAULT;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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 words. */
|
|
|
|
|
|
|
|
|
|
long
|
|
|
|
|
remote_read(memaddr, myaddr, len, increment, promcommand)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
unsigned char *myaddr;
|
|
|
|
|
int len, increment;
|
|
|
|
|
char *promcommand;
|
|
|
|
|
{
|
|
|
|
|
char buf[PBUFSIZ];
|
|
|
|
|
char buf2[PBUFSIZ];
|
|
|
|
|
int i;
|
|
|
|
|
unsigned long num;
|
|
|
|
|
|
|
|
|
|
/* Command describes registers byte by byte,
|
|
|
|
|
each byte encoded as two hex characters. */
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i += increment)
|
|
|
|
|
{
|
|
|
|
|
sprintf(buf, promcommand, memaddr + i) ;
|
|
|
|
|
remote_send(buf, buf2);
|
|
|
|
|
remote_send(".", buf);
|
|
|
|
|
if (strstr(buf2, "Exception"))
|
|
|
|
|
{
|
|
|
|
|
bzero(&myaddr[i], len - i);
|
|
|
|
|
return -i;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
char *pBuf;
|
|
|
|
|
for (pBuf = &buf[0]; *pBuf == '\r' || *pBuf == '\n'; pBuf++)
|
|
|
|
|
;
|
|
|
|
|
sscanf(pBuf, "%x\n", &num);
|
|
|
|
|
switch (increment)
|
|
|
|
|
{
|
|
|
|
|
case 1: myaddr[i] = num;
|
|
|
|
|
if (num > 255)
|
|
|
|
|
fprintf(stderr, "number out of bounds %x truncating to %x\n",
|
|
|
|
|
num, myaddr[i]);
|
|
|
|
|
break;
|
|
|
|
|
case 4: {unsigned long *p;
|
|
|
|
|
p = (unsigned long *) &myaddr[i];
|
|
|
|
|
*p = num;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
default: fprintf(stderr, "unknown increment\n"); break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 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)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
char *myaddr;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
int xfersize;
|
|
|
|
|
while (len > 0)
|
|
|
|
|
{
|
|
|
|
|
int mod;
|
|
|
|
|
|
|
|
|
|
if (len > MAXBUFBYTES)
|
|
|
|
|
xfersize = MAXBUFBYTES;
|
|
|
|
|
else
|
|
|
|
|
xfersize = len;
|
|
|
|
|
|
|
|
|
|
mod = memaddr % 4;
|
|
|
|
|
if (mod == 0 && xfersize >= 4)
|
|
|
|
|
if (mod == 0 && xfersize >= 16)
|
|
|
|
|
{
|
|
|
|
|
xfersize = remote_read_many(memaddr, myaddr, (len & ~3));
|
|
|
|
|
getpkt(IGNORE);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
xfersize = remote_read(memaddr, myaddr, 4, 4, "%x @");
|
|
|
|
|
else
|
|
|
|
|
xfersize = remote_read(memaddr, myaddr, max(mod, 1), 1, "%x c@");
|
|
|
|
|
if (xfersize <= 0)
|
|
|
|
|
return EFAULT; /* error */
|
|
|
|
|
memaddr += xfersize;
|
|
|
|
|
myaddr += xfersize;
|
|
|
|
|
len -= xfersize;
|
|
|
|
|
}
|
|
|
|
|
return 0; /* no error */
|
|
|
|
|
}
|
|
|
|
|
static int baud_rate=B38400;
|
|
|
|
|
|
|
|
|
|
static void set_term_raw(pTermio)
|
|
|
|
|
TERMINAL *pTermio;
|
|
|
|
|
{
|
|
|
|
|
pTermio->c_cflag &= (CREAD|HUPCL|CLOCAL);
|
|
|
|
|
pTermio->c_cflag |= baud_rate | CS8;
|
|
|
|
|
pTermio->c_iflag = ISTRIP /* | IXON | IXOFF */;
|
|
|
|
|
pTermio->c_oflag = 0;
|
|
|
|
|
pTermio->c_lflag = 0;
|
|
|
|
|
pTermio->c_cc[VMIN] = 0;
|
|
|
|
|
pTermio->c_cc[VTIME] = 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* setup the remote termio stream */
|
|
|
|
|
setup_remote()
|
|
|
|
|
{
|
|
|
|
|
TERMINAL temptempio;
|
|
|
|
|
|
|
|
|
|
ioctl(remote_desc, TCGETS, &temptempio);
|
|
|
|
|
set_term_raw(&temptempio);
|
|
|
|
|
ioctl(remote_desc, TCSETS, &temptempio);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* step one machine instruction */
|
|
|
|
|
remote_single_step ()
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR next_pc, npc4, target, pc;
|
|
|
|
|
typedef enum
|
|
|
|
|
{
|
* command.h, defs.h, eval.h, expression.h, remote-sa.sparc.c,
sparc-tdep.c, symtab.h, target.h, value.h, vx-share/ptrace.h,
vx-share/xdr_ptrace.h, vx-share/xdr_rdb.h: ANSIfy enums.
1991-12-19 01:14:31 +00:00
|
|
|
|
Error, not_branch, bicc, bicca, ba, baa, ticc, ta
|
1991-04-05 09:01:15 +00:00
|
|
|
|
} branch_type;
|
|
|
|
|
branch_type br, isannulled();
|
|
|
|
|
|
|
|
|
|
npc4 = remote_next_pc + 4; /* branch not taken */
|
|
|
|
|
|
|
|
|
|
/* Always set breakpoint for NPC. */
|
|
|
|
|
|
|
|
|
|
remote_insert_breakpoint(remote_next_pc);
|
|
|
|
|
remove_thisbp_next_pc = remote_next_pc;
|
|
|
|
|
|
|
|
|
|
/* printf ("set break at %x\n",remote_next_pc); */
|
|
|
|
|
|
|
|
|
|
br = isannulled (remote_pc, &target);
|
|
|
|
|
|
|
|
|
|
if (br == bicca)
|
|
|
|
|
{
|
|
|
|
|
/* Conditional annulled branch will either end up at
|
|
|
|
|
npc (if taken) or at npc+4 (if not taken).
|
|
|
|
|
Trap npc+4. */
|
|
|
|
|
remote_insert_breakpoint(npc4);
|
|
|
|
|
remove_thisbp_target = npc4;
|
|
|
|
|
}
|
|
|
|
|
else if (br == baa && target != remote_next_pc)
|
|
|
|
|
{
|
|
|
|
|
/* Unconditional annulled branch will always end up at
|
|
|
|
|
the target. */
|
|
|
|
|
remote_insert_breakpoint(target);
|
|
|
|
|
remove_thisbp_target = target;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* read many words of memory */
|
|
|
|
|
long
|
|
|
|
|
remote_read_many(memaddr, myaddr, len)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
unsigned char *myaddr;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
#define BLOCKSIZE 1024
|
|
|
|
|
static int max_number_of_blocks = 24;
|
|
|
|
|
|
|
|
|
|
char buf[PBUFSIZ];
|
|
|
|
|
char buf2[PBUFSIZ];
|
|
|
|
|
int i;
|
|
|
|
|
unsigned long *p;
|
|
|
|
|
/* Command describes registers byte by byte,
|
|
|
|
|
each byte encoded as two hex characters. */
|
|
|
|
|
|
|
|
|
|
len = min(len, max_number_of_blocks * BLOCKSIZE);
|
|
|
|
|
|
|
|
|
|
sprintf(buf, "%x %x do i @ . cr 4 +loop", memaddr + len, memaddr);
|
|
|
|
|
putpkt(buf);
|
|
|
|
|
getline(buf2, PBUFSIZ, LONGTIMEOUT); /* I don't care */
|
|
|
|
|
|
|
|
|
|
p = (unsigned long *) myaddr;
|
|
|
|
|
for (i = 0; i < len; i += 4, p++)
|
|
|
|
|
{
|
|
|
|
|
extern int InspectIt;
|
|
|
|
|
|
|
|
|
|
if (!InspectIt && ((i % BLOCKSIZE) == 0))
|
|
|
|
|
fprintf(stderr, "+"); /* let 'em know that we are working */
|
|
|
|
|
switch (getline(buf2, PBUFSIZ, LONGTIMEOUT))
|
|
|
|
|
{
|
|
|
|
|
default:
|
|
|
|
|
case GL_PROMLINE:
|
|
|
|
|
case GL_READING:
|
|
|
|
|
case GL_OK:
|
|
|
|
|
case GL_OVERRUN:
|
|
|
|
|
case GL_TIMEOUT:
|
|
|
|
|
case GL_BLANKLINE:
|
|
|
|
|
/* resync and retry */
|
|
|
|
|
max_number_of_blocks = max(1, i / BLOCKSIZE);
|
|
|
|
|
fprintf(stderr, "-"); /* let 'em know that we are working */
|
|
|
|
|
|
|
|
|
|
if (kiodebug & KD_BLOCKTRANSFER)
|
|
|
|
|
fprintf(stderr, "failed read_many %d %d/%d (%s)\n",
|
|
|
|
|
max_number_of_blocks, i, len, buf2);
|
|
|
|
|
sendbreak();
|
|
|
|
|
return remote_read_many(memaddr, myaddr, len);
|
|
|
|
|
case GL_EXCEPTION:
|
|
|
|
|
return -i;
|
|
|
|
|
case GL_SUCCESS:
|
|
|
|
|
sscanf(buf2, "%x\n", p);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
if (kiodebug & KD_BLOCKTRANSFER)
|
|
|
|
|
fprintf(stderr, "success read_many %d %d/%d (%s)\n", max_number_of_blocks,
|
|
|
|
|
i, len, buf2);
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
/*
|
|
|
|
|
* allow the user to type directly to the prom !
|
|
|
|
|
*/
|
|
|
|
|
prom_command()
|
|
|
|
|
{
|
|
|
|
|
int readUser, readProm;
|
|
|
|
|
|
|
|
|
|
user_terminal_raw();
|
|
|
|
|
fprintf(stderr, "entering prom mode...\n");
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
doselect(&readUser, &readProm);
|
|
|
|
|
if (readUser)
|
|
|
|
|
if (shuffleFromUserToProm())
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "exiting prom mode\n");
|
|
|
|
|
user_terminal_restore();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (readProm)
|
|
|
|
|
fprintf(stderr, "%c", readCharFromProm ());
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
static char *boot_set_msg = "boot needs a string in quotes of the form \"boot vmunix\" ";
|
|
|
|
|
static char *baud_set_msg = "baud rate should be of the form \"set baud=9600\"";
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
set_boot (arg, from_tty)
|
|
|
|
|
char *arg;
|
|
|
|
|
int from_tty;
|
|
|
|
|
{
|
|
|
|
|
int h, i;
|
|
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
|
{
|
|
|
|
|
print_boot_cmd();
|
|
|
|
|
error_no_arg (boot_set_msg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
arg = tilde_expand (arg);
|
|
|
|
|
make_cleanup (free, arg);
|
|
|
|
|
|
|
|
|
|
i = strlen (arg) - 1;
|
|
|
|
|
|
|
|
|
|
free (boot_cmd);
|
|
|
|
|
|
|
|
|
|
h = 0;
|
|
|
|
|
while (*arg && h < i && (arg[h] == ' ' || arg[h] == '\t'))
|
|
|
|
|
{
|
|
|
|
|
h++;
|
|
|
|
|
arg++;
|
|
|
|
|
}
|
|
|
|
|
while (i > 0 && (arg[i] == ' ' || arg[i] == '\t'))
|
|
|
|
|
i--;
|
|
|
|
|
|
|
|
|
|
if (h >= i || !*arg || arg[h] != '"' || arg[i] != '"')
|
|
|
|
|
error (boot_set_msg);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
boot_cmd = savestring (++arg, i);
|
|
|
|
|
boot_cmd[i - 1] = '\0';
|
|
|
|
|
}
|
|
|
|
|
if (from_tty)
|
|
|
|
|
print_boot_cmd();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int bauds[] = {
|
|
|
|
|
0, 50, 75, 110, 134, 150, 200, 300, 600,
|
|
|
|
|
1200, 1800, 2400, 4800, 9600, 19200, 38400, -1
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int convert_to_baud_B(n)
|
|
|
|
|
int n;
|
|
|
|
|
{
|
|
|
|
|
register int *p;
|
|
|
|
|
|
|
|
|
|
for (p = bauds; *p != -1; p++)
|
|
|
|
|
if (*p != 0 && *p == n)
|
|
|
|
|
return (p - bauds);
|
|
|
|
|
return (NULL);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void print_acceptable_bauds()
|
|
|
|
|
{
|
|
|
|
|
register int *p;
|
|
|
|
|
|
|
|
|
|
for (p = bauds; *p != -1; p++)
|
|
|
|
|
if (*p != 0 )
|
|
|
|
|
fprintf(stderr, "%d\n", *p);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void print_baud()
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "the baud rate is now %d\n", bauds[baud_rate]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
set_baud (arg, from_tty)
|
|
|
|
|
char *arg;
|
|
|
|
|
int from_tty;
|
|
|
|
|
{
|
|
|
|
|
int temp_baud_rate;
|
|
|
|
|
|
|
|
|
|
if (!arg)
|
|
|
|
|
{
|
|
|
|
|
print_baud();
|
|
|
|
|
print_acceptable_bauds();
|
|
|
|
|
error_no_arg (baud_set_msg);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (*arg && !isdigit(*arg))
|
|
|
|
|
arg++;
|
|
|
|
|
|
|
|
|
|
if (*arg && (temp_baud_rate = convert_to_baud_B(atoi(arg))) != NULL)
|
|
|
|
|
{
|
|
|
|
|
baud_rate = temp_baud_rate;
|
|
|
|
|
if (remote_debugging)
|
|
|
|
|
setup_remote();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
fprintf(stderr, "bad baud rate %s, acceptable values are\n", arg);
|
|
|
|
|
print_acceptable_bauds();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
print_baud();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_initialize_remote()
|
|
|
|
|
{
|
|
|
|
|
/* Chain containing all defined set subcommands */
|
|
|
|
|
|
|
|
|
|
extern struct cmd_list_element *setlist;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
add_com ("prom", class_obscure, prom_command,
|
|
|
|
|
"Conduct a dialogue directly with the prom. \
|
|
|
|
|
only useful after an attach\n\
|
|
|
|
|
Terminate by typing ~.");
|
|
|
|
|
|
|
|
|
|
add_cmd ("boot_cmd", class_support, set_boot, boot_set_msg, &setlist);
|
|
|
|
|
|
|
|
|
|
add_cmd ("baud", class_support, set_baud, baud_set_msg, &setlist);
|
|
|
|
|
|
|
|
|
|
set_boot ("\"boot nucleus -d\"", 0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Store the remote registers from the contents of the block REGS. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
remote_store_registers (registers)
|
|
|
|
|
char *registers;
|
|
|
|
|
{
|
|
|
|
|
CORE_ADDR core;
|
|
|
|
|
struct regs inferior_registers;
|
|
|
|
|
|
|
|
|
|
core = parse_and_eval_address("breakpoint_regs");
|
|
|
|
|
|
|
|
|
|
bcopy (®isters[REGISTER_BYTE (1)],
|
|
|
|
|
&inferior_registers.r_g1, 15 * 4);
|
|
|
|
|
|
|
|
|
|
inferior_registers.r_ps =
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (PS_REGNUM)];
|
|
|
|
|
inferior_registers.r_pc =
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (PC_REGNUM)];
|
|
|
|
|
inferior_registers.r_npc =
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (NPC_REGNUM)];
|
|
|
|
|
inferior_registers.r_y =
|
|
|
|
|
*(int *)®isters[REGISTER_BYTE (Y_REGNUM)];
|
|
|
|
|
|
|
|
|
|
remote_write_inferior_memory (*(int *)®isters[REGISTER_BYTE (SP_REGNUM)],
|
|
|
|
|
®isters[REGISTER_BYTE (16)],
|
|
|
|
|
16*4);
|
|
|
|
|
remote_write_inferior_memory (core,
|
|
|
|
|
&inferior_registers,
|
|
|
|
|
sizeof(inferior_registers));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* we have stopped. do some cleanup */
|
|
|
|
|
remote_cleanup_after_stop()
|
|
|
|
|
{
|
|
|
|
|
if (remove_thisbp_next_pc)
|
|
|
|
|
{
|
|
|
|
|
remote_remove_breakpoint (remove_thisbp_next_pc);
|
|
|
|
|
remove_thisbp_next_pc = 0;
|
|
|
|
|
}
|
|
|
|
|
if (remove_thisbp_target)
|
|
|
|
|
{
|
|
|
|
|
remote_remove_breakpoint (remove_thisbp_target);
|
|
|
|
|
remove_thisbp_target = 0;
|
|
|
|
|
}
|
|
|
|
|
user_terminal_restore();
|
|
|
|
|
|
|
|
|
|
one_stepped = remote_set_one_stepped;
|
|
|
|
|
}
|