remote-nindy.c

早期freebsd实现

/* Memory-access and commands for remote NINDY process, for GDB.
   Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
   Contributed by Intel Corporation.  Modified from remote.c by Chris Benenati.

GDB is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY.  No author or distributor accepts responsibility to anyone
for the consequences of using it or for whether it serves any
particular purpose or works at all, unless he says so in writing.
Refer to the GDB General Public License for full details.

Everyone is granted permission to copy, modify and redistribute GDB,
but only under the conditions described in the GDB General Public
License.  A copy of this license is supposed to have been given to you
along with GDB so you can know your rights and responsibilities.  It
should be in a file named COPYING.  Among other things, the copyright
notice and this notice must be preserved on all copies.

In other words, go ahead and share GDB, but don't try to stop
anyone else from sharing it farther.  Help stamp out software hoarding!
*/

/*
Except for the data cache routines, this file bears little resemblence
to remote.c.  A new (although similar) protocol has been specified, and
portions of the code are entirely dependent on having an i80960 with a
NINDY ROM monitor at the other end of the line.
*/

/*****************************************************************************
 *
 * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR.
 *
 *
 * MODES OF OPERATION
 * ----- -- ---------
 *	
 * As far as NINDY is concerned, GDB is always in one of two modes: command
 * mode or passthrough mode.
 *
 * In command mode (the default) pre-defined packets containing requests
 * are sent by GDB to NINDY.  NINDY never talks except in reponse to a request.
 *
 * Once the the user program is started, GDB enters passthrough mode, to give
 * the user program access to the terminal.  GDB remains in this mode until
 * NINDY indicates that the program has stopped.
 *
 *
 * PASSTHROUGH MODE
 * ----------- ----
 *
 * GDB writes all input received from the keyboard directly to NINDY, and writes
 * all characters received from NINDY directly to the monitor.
 *
 * Keyboard input is neither buffered nor echoed to the monitor.
 *
 * GDB remains in passthrough mode until NINDY sends a single ^P character,
 * to indicate that the user process has stopped.
 *
 * Note:
 *	GDB assumes NINDY performs a 'flushreg' when the user program stops.
 *
 *
 * COMMAND MODE
 * ------- ----
 *
 * All info (except for message ack and nak) is transferred between gdb
 * and the remote processor in messages of the following format:
 *
 *		<info>#<checksum>
 *
 * where 
 *	#	is a literal character
 *
 *	<info>	ASCII information;  all numeric information is in the
 *		form of hex digits ('0'-'9' and lowercase 'a'-'f').
 *
 *	<checksum>
 *		is a pair of ASCII hex digits representing an 8-bit
 *		checksum formed by adding together each of the
 *		characters in <info>.
 *
 * The receiver of a message always sends a single character to the sender
 * to indicate that the checksum was good ('+') or bad ('-');  the sender
 * re-transmits the entire message over until a '+' is received.
 *
 * In response to a command NINDY always sends back either data or
 * a result code of the form "Xnn", where "nn" are hex digits and "X00"
 * means no errors.  (Exceptions: the "s" and "c" commands don't respond.)
 *
 * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A
 * FULL DESCRIPTION OF LEGAL COMMANDS.
 *
 * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST
 * OF STOP CODES.
 *
 ******************************************************************************/

#include "defs.h"
#include <signal.h>
#include <sys/types.h>
#include <setjmp.h>

#include "frame.h"
#include "inferior.h"
#include "target.h"
#include "gdbcore.h"
#include "command.h"
#include "bfd.h"
#include "ieee-float.h"

#include "wait.h"
#include <sys/ioctl.h>
#include <sys/file.h>
#include <ctype.h>
#include "nindy-share/ttycntl.h"
#include "nindy-share/demux.h"
#include "nindy-share/env.h"
#include "nindy-share/stop.h"

extern int unlink();
extern char *getenv();
extern char *mktemp();

extern char *coffstrip();
extern void generic_mourn_inferior ();

extern struct target_ops nindy_ops;
extern jmp_buf to_top_level;
extern FILE *instream;
extern struct ext_format ext_format_i960;	/* i960-tdep.c */

extern char ninStopWhy ();

int nindy_initial_brk;	/* nonzero if want to send an initial BREAK to nindy */
int nindy_old_protocol;	/* nonzero if want to use old protocol */
char *nindy_ttyname;	/* name of tty to talk to nindy on, or null */

#define DLE	'\020'	/* Character NINDY sends to indicate user program has
			 * halted.  */
#define TRUE	1
#define FALSE	0

int nindy_fd = 0;	/* Descriptor for I/O to NINDY  */
static int have_regs = 0;	/* 1 iff regs read since i960 last halted */
static int regs_changed = 0;	/* 1 iff regs were modified since last read */

extern char *exists();

static void
dcache_flush (), dcache_poke (), dcache_init();

static int
dcache_fetch ();

static void
nindy_fetch_registers PARAMS ((int));

static void
nindy_store_registers PARAMS ((int));

/* FIXME, we can probably use the normal terminal_inferior stuff here.
   We have to do terminal_inferior and then set up the passthrough
   settings initially.  Thereafter, terminal_ours and terminal_inferior
   will automatically swap the settings around for us.  */

/* Restore TTY to normal operation */

static TTY_STRUCT orig_tty;	/* TTY attributes before entering passthrough */

static void
restore_tty()
{
	ioctl( 0, TIOCSETN, &orig_tty );
}


/* Recover from ^Z or ^C while remote process is running */

static void (*old_ctrlc)();    /* Signal handlers before entering passthrough */

#ifdef SIGTSTP
static void (*old_ctrlz)();
#endif

static
#ifdef USG
void
#endif
cleanup()
{
	restore_tty();
	signal(SIGINT, old_ctrlc);
#ifdef SIGTSTP
	signal(SIGTSTP, old_ctrlz);
#endif
	error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
}

/* Clean up anything that needs cleaning when losing control.  */

static char *savename;

static void
nindy_close (quitting)
     int quitting;
{
  if (nindy_fd)
    close (nindy_fd);
  nindy_fd = 0;

  if (savename)
    free (savename);
  savename = 0;
}

/* Open a connection to a remote debugger.   
   FIXME, there should be a way to specify the various options that are
   now specified with gdb command-line options.  (baud_rate, old_protocol,
   and initial_brk)  */
void
nindy_open (name, from_tty)
    char *name;		/* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
    int from_tty;
{

  if (!name)
    error_no_arg ("serial port device name");

  target_preopen (from_tty);
  
  nindy_close (0);

	have_regs = regs_changed = 0;
	dcache_init();

	/* Allow user to interrupt the following -- we could hang if
	 * there's no NINDY at the other end of the remote tty.
	 */
	immediate_quit++;
	nindy_fd = ninConnect( name, baud_rate? baud_rate: "9600",
			nindy_initial_brk, !from_tty, nindy_old_protocol );
	immediate_quit--;

	if ( nindy_fd < 0 ){
		nindy_fd = 0;
		error( "Can't open tty '%s'", name );
	}

        savename = savestring (name, strlen (name));
	push_target (&nindy_ops);
	target_fetch_registers(-1);
}

/* User-initiated quit of nindy operations.  */

static void
nindy_detach (name, from_tty)
     char *name;
     int from_tty;
{
  if (name)
    error ("Too many arguments");
  pop_target ();
}

static void
nindy_files_info ()
{
  printf("\tAttached to %s at %s bps%s%s.\n", savename,
	 baud_rate? baud_rate: "9600",
	 nindy_old_protocol? " in old protocol": "",
         nindy_initial_brk? " with initial break": "");
}

/******************************************************************************
 * remote_load:
 *	Download an object file to the remote system by invoking the "comm960"
 *	utility.  We look for "comm960" in $G960BIN, $G960BASE/bin, and
 *	DEFAULT_BASE/bin/HOST/bin where
 *		DEFAULT_BASE is defined in env.h, and
 *		HOST must be defined on the compiler invocation line.
 ******************************************************************************/

static void
nindy_load( filename, from_tty )
    char *filename;
    int from_tty;
{
  asection *s;
  /* Can't do unix style forking on a VMS system, so we'll use bfd to do
     all the work for us 
     */

  bfd *file = bfd_openr(filename,0);
  if (!file) 
  {
    perror_with_name(filename);
    return;
  }
  
  if (!bfd_check_format(file, bfd_object)) 
  {
    error("can't prove it's an object file\n");
    return;
  }
  
  for ( s = file->sections; s; s=s->next) 
  {
    if (s->flags & SEC_LOAD) 
    {
      char *buffer = xmalloc(s->_raw_size);
      bfd_get_section_contents(file, s, buffer, 0, s->_raw_size);
      printf("Loading section %s, size %x vma %x\n",
	     s->name, 
	     s->_raw_size,
	     s->vma);
      ninMemPut(s->vma, buffer, s->_raw_size);
      free(buffer);
    }
  }
  bfd_close(file);
}

/* Return the number of characters in the buffer before the first DLE character.
 */

static
int
non_dle( buf, n )
    char *buf;		/* Character buffer; NOT '\0'-terminated */
    int n;		/* Number of characters in buffer */
{
	int i;

	for ( i = 0; i < n; i++ ){
		if ( buf[i] == DLE ){
			break;
		}
	}
	return i;
}

/* Tell the remote machine to resume.  */

void
nindy_resume (step, siggnal)
     int step, siggnal;
{
	if (siggnal != 0 && siggnal != stop_signal)
	  error ("Can't send signals to remote NINDY targets.");

	dcache_flush();
	if ( regs_changed ){
		nindy_store_registers ();
		regs_changed = 0;
	}
	have_regs = 0;
	ninGo( step );
}

/* Wait until the remote machine stops. While waiting, operate in passthrough
 * mode; i.e., pass everything NINDY sends to stdout, and everything from
 * stdin to NINDY.
 *
 * Return to caller, storing status in 'status' just as `wait' would.
 */

static int
nindy_wait( status )
    WAITTYPE *status;
{
	DEMUX_DECL;	/* OS-dependent data needed by DEMUX... macros */
	char buf[500];	/* FIXME, what is "500" here? */
	int i, n;
	unsigned char stop_exit;
	unsigned char stop_code;
	TTY_STRUCT tty;
	long ip_value, fp_value, sp_value;	/* Reg values from stop */


	WSETEXIT( (*status), 0 );

	/* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */

	/* Save current tty attributes, set up signals to restore them.
	 */
	ioctl( 0, TIOCGETP, &orig_tty );
	old_ctrlc = signal( SIGINT, cleanup );
#ifdef SIGTSTP
	old_ctrlz = signal( SIGTSTP, cleanup );
#endif

	/* Pass input from keyboard to NINDY as it arrives.
	 * NINDY will interpret <CR> and perform echo.
	 */
	tty = orig_tty;
	TTY_NINDYTERM( tty );
	ioctl( 0, TIOCSETN, &tty );

	while ( 1 ){
		/* Go to sleep until there's something for us on either
		 * the remote port or stdin.
		 */

		DEMUX_WAIT( nindy_fd );

		/* Pass input through to correct place */

		n = DEMUX_READ( 0, buf, sizeof(buf) );
		if ( n ){				/* Input on stdin */
			write( nindy_fd, buf, n );
		}

		n = DEMUX_READ( nindy_fd, buf, sizeof(buf) );
		if ( n ){				/* Input on remote */
			/* Write out any characters in buffer preceding DLE */
			i = non_dle( buf, n );
			if ( i > 0 ){
				write( 1, buf, i );
			}

			if ( i != n ){
				/* There *was* a DLE in the buffer */
				stop_exit = ninStopWhy( &stop_code,
					&ip_value, &fp_value, &sp_value);
				if ( !stop_exit && (stop_code==STOP_SRQ) ){
					immediate_quit++;
					ninSrq();
					immediate_quit--;
				} else {
					/* Get out of loop */
					supply_register (IP_REGNUM, &ip_value);
					supply_register (FP_REGNUM, &fp_value);
					supply_register (SP_REGNUM, &sp_value);
					break;
				}
			}
		}
	}

	signal( SIGINT, old_ctrlc );
#ifdef SIGTSTP
	signal( SIGTSTP, old_ctrlz );
#endif
	restore_tty();

	if ( stop_exit ){			/* User program exited */
		WSETEXIT( (*status), stop_code );
	} else {				/* Fault or trace */
		switch (stop_code){
		case STOP_GDB_BPT:
		case TRACE_STEP:
			/* Make it look like a VAX trace trap */
			stop_code = SIGTRAP;
			break;
		default:
			/* The target is not running Unix, and its
			   faults/traces do not map nicely into Unix signals.
			   Make sure they do not get confused with Unix signals
			   by numbering them with values higher than the highest
			   legal Unix signal.  code in i960_print_fault(),
			   called via PRINT_RANDOM_SIGNAL, will interpret the
			   value.  */
			stop_code += NSIG;
			break;
		}
		WSETSTOP( (*status), stop_code );
	}
	return inferior_pid;
}

/* Read the remote registers into the block REGS.  */

/* This is the block that ninRegsGet and ninRegsPut handles.  */
struct nindy_regs {
  char	local_regs[16 * 4];
  char	global_regs[16 * 4];
  char	pcw_acw[2 * 4];
  char	ip[4];
  char	tcw[4];
  char	fp_as_double[4 * 8];
};

static void
nindy_fetch_registers(regno)
     int regno;