[deliverable/binutils-gdb.git] / sim / arm / kid.c

/*  kid.c -- ARMulator RDP/RDI interface:  ARM6 Instruction Emulator.
    Copyright (C) 1994 Advanced RISC Machines Ltd.
 
    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 3 of the License, or
    (at your option) any later version.
 
    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 this program; if not, see <http://www.gnu.org/licenses/>. */

/*****************************************************************/
/* The child process continues here...                           */
/* It waits on a pipe from the parent and translates the RDP     */
/* messages into RDI calls to the ARMulator passing RDP replies  */
/* back up a pipe to the parent.                                 */
/*****************************************************************/

#include <sys/types.h>
#include <signal.h>

#include "armdefs.h"
#include "dbg_conf.h"
#include "dbg_hif.h"
#include "dbg_rdi.h"
#include "gdbhost.h"
#include "communicate.h"

/* The pipes between the two processes */
extern int mumkid[2];
extern int kidmum[2];

/* The maximum number of file descriptors */
extern int nfds;

/* The machine name */
#define MAXHOSTNAMELENGTH 64
extern char localhost[MAXHOSTNAMELENGTH + 1];

/* The socket number */
extern unsigned int socketnumber;

/* RDI interface */
extern const struct RDIProcVec armul_rdi;

static int MYrdp_level = 0;

static int rdi_state = 0;

/**************************************************************/
/* Signal handler that terminates excecution in the ARMulator */
/**************************************************************/
void
kid_handlesignal (int sig)
{
#ifdef DEBUG
  fprintf (stderr, "Terminate ARMulator excecution\n");
#endif
  if (sig != SIGUSR1)
    {
      fprintf (stderr, "Unsupported signal.\n");
      return;
    }
  armul_rdi.info (RDISignal_Stop, (unsigned long *) 0, (unsigned long *) 0);
}

/********************************************************************/
/* Waits on a pipe from the socket demon for RDP and                */
/* acts as an RDP to RDI interpreter on the front of the ARMulator. */
/********************************************************************/
void
kid ()
{
  char *p, *q;
  int i, j, k;
  long outofthebag;
  unsigned char c, d, message;
  ARMword x, y, z;
  struct sigaction action;
  PointHandle point;
  Dbg_ConfigBlock config;
  Dbg_HostosInterface hostif;
  struct Dbg_MCState *MCState;
  char command_line[256];
  struct fd_set readfds;

  /* Setup a signal handler for SIGUSR1 */
  action.sa_handler = kid_handlesignal;
  action.sa_mask = 0;
  action.sa_flags = 0;

  sigaction (SIGUSR1, &action, (struct sigaction *) 0);

  while (1)
    {
      /* Wait for ever */
      FD_ZERO (&readfds);
      FD_SET (mumkid[0], &readfds);

      i = select (nfds, &readfds,
		  (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0);

      if (i < 0)
	{
	  perror ("select");
	}

      if (read (mumkid[0], &message, 1) < 1)
	{
	  perror ("read");
	}

      switch (message)
	{
	case RDP_Start:
	  /* Open and/or Initialise */
	  BAG_newbag ();

	  MYread_char (mumkid[0], &c);	/* type */
	  MYread_word (mumkid[0], &x);	/* memorysize */
	  if (c & 0x2)
	    MYread_char (mumkid[0], &d);	/* speed */
	  config.processor = 0;
	  config.memorysize = x;
	  config.bytesex = (c & 0x4) ? RDISex_Big : RDISex_Little;
	  if (c & 0x8)
	    config.bytesex = RDISex_DontCare;

	  hostif.dbgprint = myprint;
	  hostif.dbgpause = mypause;
	  hostif.dbgarg = stdout;
	  hostif.writec = mywritec;
	  hostif.readc = myreadc;
	  hostif.write = mywrite;
	  hostif.gets = mygets;
	  hostif.reset = mypause;	/* do nothing */
	  hostif.resetarg = "Do I love resetting or what!\n";

	  if (rdi_state)
	    {
	      /* we have restarted, so kill off the existing run.  */
	      /* armul_rdi.close(); */
	    }
	  i = armul_rdi.open (c & 0x3, &config, &hostif, MCState);
	  rdi_state = 1;

	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);

	  x = ~0x4;
	  armul_rdi.info (RDIVector_Catch, &x, 0);

	  break;

	case RDP_End:
	  /* Close and Finalise */
	  i = armul_rdi.close ();
	  rdi_state = 0;
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_Read:
	  /* Read Memory Address */
	  MYread_word (mumkid[0], &x);	/* address */
	  MYread_word (mumkid[0], &y);	/* nbytes */
	  p = (char *) malloc (y);
	  i = armul_rdi.read (x, p, (unsigned *) &y);
	  MYwrite_char (kidmum[1], RDP_Return);
	  for (k = 0; k < y; k++)
	    MYwrite_char (kidmum[1], p[k]);
	  free (p);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  if (i)
	    MYwrite_word (kidmum[1], y);	/* number of bytes sent without error */
	  break;

	case RDP_Write:
	  /* Write Memory Address */
	  MYread_word (mumkid[0], &x);	/* address */
	  MYread_word (mumkid[0], &y);	/* nbytes */
	  p = (char *) malloc (y);
	  for (k = 0; k < y; k++)
	    MYread_char (mumkid[0], &p[k]);
	  i = armul_rdi.write (p, x, (unsigned *) &y);
	  free (p);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  if (i)
	    MYwrite_word (kidmum[1], y);	/* number of bytes sent without error */
	  break;

	case RDP_CPUread:
	  /* Read CPU State */
	  MYread_char (mumkid[0], &c);	/* mode */
	  MYread_word (mumkid[0], &x);	/* mask */
	  p = (char *) malloc (4 * RDINumCPURegs);
	  i = armul_rdi.CPUread (c, x, (ARMword *) p);
	  MYwrite_char (kidmum[1], RDP_Return);
	  for (k = 1, j = 0; k != 0x80000000; k *= 2)
	    if (k & x)
	      MYwrite_word (kidmum[1], ((ARMword *) p)[j++]);
	  free (p);
	  if (i)
	    MYwrite_char (kidmum[1], (unsigned char) j);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_CPUwrite:
	  /* Write CPU State */
	  MYread_char (mumkid[0], &c);	/* mode */
	  MYread_word (mumkid[0], &x);	/* mask */

	  p = (char *) malloc (4 * RDINumCPURegs);
	  for (k = 1, j = 0; k != 0x80000000; k *= 2)
	    if (k & x)
	      MYread_word (mumkid[0], &(((ARMword *) p)[j++]));
	  i = armul_rdi.CPUwrite (c, x, (ARMword *) p);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  free (p);
	  break;

	case RDP_CPread:
	  /* Read Co-Processor State */
	  MYread_char (mumkid[0], &c);	/* CPnum */
	  MYread_word (mumkid[0], &x);	/* mask */
	  p = q = (char *) malloc (16 * RDINumCPRegs);
	  i = armul_rdi.CPread (c, x, (ARMword *) p);
	  MYwrite_char (kidmum[1], RDP_Return);
	  for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
	    if (k & x)
	      {
		if ((c == 1 || c == 2) && k <= 128)
		  {
		    MYwrite_FPword (kidmum[1], q);
		    q += 16;
		  }
		else
		  {
		    MYwrite_word (kidmum[1], *q);
		    q += 4;
		  }
	      }
	  free (p);
	  if (i)
	    MYwrite_char (kidmum[1], (unsigned char) j);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_CPwrite:
	  /* Write Co-Processor State */
	  MYread_char (mumkid[0], &c);	/* CPnum */
	  MYread_word (mumkid[0], &x);	/* mask */
	  p = q = (char *) malloc (16 * RDINumCPURegs);
	  for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
	    if (k & x)
	      {
		if ((c == 1 || c == 2) && k <= 128)
		  {
		    MYread_FPword (kidmum[1], q);
		    q += 16;
		  }
		else
		  {
		    MYread_word (mumkid[0], (ARMword *) q);
		    q += 4;
		  }
	      }
	  i = armul_rdi.CPwrite (c, x, (ARMword *) p);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  free (p);
	  break;

	case RDP_SetBreak:
	  /* Set Breakpoint */
	  MYread_word (mumkid[0], &x);	/* address */
	  MYread_char (mumkid[0], &c);	/* type */
	  if ((c & 0xf) >= 5)
	    MYread_word (mumkid[0], &y);	/* bound */
	  i = armul_rdi.setbreak (x, c, y, &point);
	  if (!MYrdp_level)
	    BAG_putpair ((long) x, (long) point);
	  MYwrite_char (kidmum[1], RDP_Return);
	  if (MYrdp_level)
	    MYwrite_word (kidmum[1], point);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_ClearBreak:
	  /* Clear Breakpoint */
	  MYread_word (mumkid[0], &point);	/* PointHandle */
	  if (!MYrdp_level)
	    {
	      BAG_getsecond ((long) point, &outofthebag);	/* swap pointhandle for address */
	      BAG_killpair_byfirst (outofthebag);
	      point = outofthebag;
	    }
	  i = armul_rdi.clearbreak (point);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_SetWatch:
	  /* Set Watchpoint */
	  MYread_word (mumkid[0], &x);	/* address */
	  MYread_char (mumkid[0], &c);	/* type */
	  MYread_char (mumkid[0], &d);	/* datatype */
	  if ((c & 0xf) >= 5)
	    MYread_word (mumkid[0], &y);	/* bound */
	  i = armul_rdi.setwatch (x, c, d, y, &point);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_word (kidmum[1], point);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_ClearWatch:
	  /* Clear Watchpoint */
	  MYread_word (mumkid[0], &point);	/* PointHandle */
	  i = armul_rdi.clearwatch (point);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_Execute:
	  /* Excecute */

	  MYread_char (mumkid[0], &c);	/* return */

#ifdef DEBUG
	  fprintf (stderr, "Starting execution\n");
#endif
	  i = armul_rdi.execute (&point);
#ifdef DEBUG
	  fprintf (stderr, "Completed execution\n");
#endif
	  MYwrite_char (kidmum[1], RDP_Return);
	  if (c & 0x80)
	    MYwrite_word (kidmum[1], point);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_Step:
	  /* Step */
	  MYread_char (mumkid[0], &c);	/* return */
	  MYread_word (mumkid[0], &x);	/* ninstr */
	  point = 0x87654321;
	  i = armul_rdi.step (x, &point);
	  MYwrite_char (kidmum[1], RDP_Return);
	  if (c & 0x80)
	    MYwrite_word (kidmum[1], point);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  break;

	case RDP_Info:
	  /* Info */
	  MYread_word (mumkid[0], &x);
	  switch (x)
	    {
	    case RDIInfo_Target:
	      i = armul_rdi.info (RDIInfo_Target, &y, &z);
	      MYwrite_char (kidmum[1], RDP_Return);
	      MYwrite_word (kidmum[1], y);	/* Loads of info... */
	      MYwrite_word (kidmum[1], z);	/* Model */
	      MYwrite_char (kidmum[1], (unsigned char) i);
	      break;

	    case RDISet_RDILevel:
	      MYread_word (mumkid[0], &x);	/* arg1, debug level */
	      i = armul_rdi.info (RDISet_RDILevel, &x, 0);
	      if (i == RDIError_NoError)
		MYrdp_level = x;
	      MYwrite_char (kidmum[1], RDP_Return);
	      MYwrite_char (kidmum[1], (unsigned char) i);
	      break;

	    case RDISet_Cmdline:
	      for (p = command_line; MYread_char (mumkid[0], p), *p; p++)
		;		/* String */
	      i = armul_rdi.info (RDISet_Cmdline,
				  (unsigned long *) command_line, 0);
	      MYwrite_char (kidmum[1], RDP_Return);
	      MYwrite_char (kidmum[1], (unsigned char) i);
	      break;

	    case RDIInfo_Step:
	      i = armul_rdi.info (RDIInfo_Step, &x, 0);
	      MYwrite_char (kidmum[1], RDP_Return);
	      MYwrite_word (kidmum[1], x);
	      MYwrite_char (kidmum[1], (unsigned char) i);
	      break;

	    case RDIVector_Catch:
	      MYread_word (mumkid[0], &x);
	      i = armul_rdi.info (RDIVector_Catch, &x, 0);
	      MYwrite_char (kidmum[1], RDP_Return);
	      MYwrite_char (kidmum[1], i);
	      break;

	    case RDIInfo_Points:
	      i = armul_rdi.info (RDIInfo_Points, &x, 0);
	      MYwrite_char (kidmum[1], RDP_Return);
	      MYwrite_word (kidmum[1], x);
	      MYwrite_char (kidmum[1], (unsigned char) i);
	      break;

	    default:
	      fprintf (stderr, "Unsupported info code %d\n", x);
	      break;
	    }
	  break;

	case RDP_OSOpReply:
	  /* OS Operation Reply */
	  MYwrite_char (kidmum[1], RDP_Fatal);
	  break;

	case RDP_Reset:
	  /* Reset */
	  for (i = 0; i < 50; i++)
	    MYwrite_char (kidmum[1], RDP_Reset);
	  p = (char *) malloc (MAXHOSTNAMELENGTH + 5 + 20);
	  sprintf (p, "Running on %s:%d\n", localhost, socketnumber);
	  MYwrite_string (kidmum[1], p);
	  free (p);

	  break;
	default:
	  fprintf (stderr, "Oh dear: Something is seriously wrong :-(\n");
	  /* Hmm.. bad RDP operation */
	  break;
	}
    }
}


/* Handles memory read operations until an OS Operation Reply Message is */
/* encounterd. It then returns the byte info value (0, 1, or 2) and fills  */
/* in 'putinr0' with the data if appropriate. */
int
wait_for_osreply (ARMword * reply)
{
  char *p, *q;
  int i, j, k;
  unsigned char c, d, message;
  ARMword x, y, z;
  struct sigaction action;
  PointHandle point;
  Dbg_ConfigBlock config;
  Dbg_HostosInterface hostif;
  struct Dbg_MCState *MCState;
  char command_line[256];
  struct fd_set readfds;

#ifdef DEBUG
  fprintf (stderr, "wait_for_osreply ().\n");
#endif

  /* Setup a signal handler for SIGUSR1 */
  action.sa_handler = kid_handlesignal;
  action.sa_mask = 0;
  action.sa_flags = 0;

  sigaction (SIGUSR1, &action, (struct sigaction *) 0);

  while (1)
    {
      /* Wait for ever */
      FD_ZERO (&readfds);
      FD_SET (mumkid[0], &readfds);

      i = select (nfds, &readfds,
		  (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0);

      if (i < 0)
	{
	  perror ("select");
	}

      if (read (mumkid[0], &message, 1) < 1)
	{
	  perror ("read");
	}

      switch (message)
	{
	case RDP_Read:
	  /* Read Memory Address */
	  MYread_word (mumkid[0], &x);	/* address */
	  MYread_word (mumkid[0], &y);	/* nbytes */
	  p = (char *) malloc (y);
	  i = armul_rdi.read (x, p, (unsigned *) &y);
	  MYwrite_char (kidmum[1], RDP_Return);
	  for (k = 0; k < y; k++)
	    MYwrite_char (kidmum[1], p[k]);
	  free (p);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  if (i)
	    MYwrite_word (kidmum[1], y);	/* number of bytes sent without error */
	  break;

	case RDP_Write:
	  /* Write Memory Address */
	  MYread_word (mumkid[0], &x);	/* address */
	  MYread_word (mumkid[0], &y);	/* nbytes */
	  p = (char *) malloc (y);
	  for (k = 0; k < y; k++)
	    MYread_char (mumkid[0], &p[k]);
	  i = armul_rdi.write (p, x, (unsigned *) &y);
	  free (p);
	  MYwrite_char (kidmum[1], RDP_Return);
	  MYwrite_char (kidmum[1], (unsigned char) i);
	  if (i)
	    MYwrite_word (kidmum[1], y);	/* number of bytes sent without error */
	  break;

	case RDP_OSOpReply:
	  /* OS Operation Reply */
	  MYread_char (mumkid[0], &c);
	  if (c == 1)
	    MYread_char (mumkid[0], (char *) reply);
	  if (c == 2)
	    MYread_word (mumkid[0], reply);
	  return c;
	  break;

	default:
	  fprintf (stderr,
		   "HELP! Unaccounted-for message during OS request. \n");
	  MYwrite_char (kidmum[1], RDP_Fatal);
	}
    }
}
Commit	Line	Data
c906108c SS	1	/* kid.c -- ARMulator RDP/RDI interface: ARM6 Instruction Emulator.
	2	Copyright (C) 1994 Advanced RISC Machines Ltd.
	3
	4	This program is free software; you can redistribute it and/or modify
	5	it under the terms of the GNU General Public License as published by
3fd725ef	6	the Free Software Foundation; either version 3 of the License, or
c906108c SS	7	(at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
51b318de	15	along with this program; if not, see <http://www.gnu.org/licenses/>. */
c906108c SS	16
	17	/*****************************************************************/
	18	/* The child process continues here... */
	19	/* It waits on a pipe from the parent and translates the RDP */
	20	/* messages into RDI calls to the ARMulator passing RDP replies */
	21	/* back up a pipe to the parent. */
	22	/*****************************************************************/
	23
	24	#include <sys/types.h>
	25	#include <signal.h>
	26
	27	#include "armdefs.h"
	28	#include "dbg_conf.h"
	29	#include "dbg_hif.h"
	30	#include "dbg_rdi.h"
	31	#include "gdbhost.h"
	32	#include "communicate.h"
	33
	34	/* The pipes between the two processes */
	35	extern int mumkid[2];
	36	extern int kidmum[2];
	37
	38	/* The maximum number of file descriptors */
	39	extern int nfds;
	40
	41	/* The machine name */
	42	#define MAXHOSTNAMELENGTH 64
	43	extern char localhost[MAXHOSTNAMELENGTH + 1];
	44
	45	/* The socket number */
	46	extern unsigned int socketnumber;
	47
	48	/* RDI interface */
	49	extern const struct RDIProcVec armul_rdi;
	50
	51	static int MYrdp_level = 0;
	52
	53	static int rdi_state = 0;
	54
	55	/**************************************************************/
	56	/* Signal handler that terminates excecution in the ARMulator */
	57	/**************************************************************/
dfcd3bfb JM	58	void
	59	kid_handlesignal (int sig)
	60	{
c906108c	61	#ifdef DEBUG
dfcd3bfb	62	fprintf (stderr, "Terminate ARMulator excecution\n");
c906108c	63	#endif
dfcd3bfb JM	64	if (sig != SIGUSR1)
	65	{
	66	fprintf (stderr, "Unsupported signal.\n");
	67	return;
	68	}
	69	armul_rdi.info (RDISignal_Stop, (unsigned long ) 0, (unsigned long ) 0);
c906108c SS	70	}
	71
	72	/********************************************************************/
	73	/* Waits on a pipe from the socket demon for RDP and */
	74	/* acts as an RDP to RDI interpreter on the front of the ARMulator. */
	75	/********************************************************************/
dfcd3bfb JM	76	void
	77	kid ()
	78	{
c906108c SS	79	char p, q;
	80	int i, j, k;
	81	long outofthebag;
	82	unsigned char c, d, message;
	83	ARMword x, y, z;
	84	struct sigaction action;
	85	PointHandle point;
	86	Dbg_ConfigBlock config;
	87	Dbg_HostosInterface hostif;
	88	struct Dbg_MCState *MCState;
	89	char command_line[256];
	90	struct fd_set readfds;
dfcd3bfb	91
c906108c SS	92	/* Setup a signal handler for SIGUSR1 */
	93	action.sa_handler = kid_handlesignal;
	94	action.sa_mask = 0;
	95	action.sa_flags = 0;
dfcd3bfb JM	96
	97	sigaction (SIGUSR1, &action, (struct sigaction *) 0);
	98
c906108c	99	while (1)
dfcd3bfb JM	100	{
	101	/* Wait for ever */
	102	FD_ZERO (&readfds);
	103	FD_SET (mumkid[0], &readfds);
	104
	105	i = select (nfds, &readfds,
	106	(fd_set ) 0, (fd_set ) 0, (struct timeval *) 0);
c906108c	107
dfcd3bfb JM	108	if (i < 0)
	109	{
	110	perror ("select");
c906108c	111	}
dfcd3bfb JM	112
	113	if (read (mumkid[0], &message, 1) < 1)
	114	{
	115	perror ("read");
c906108c	116	}
c906108c	117
dfcd3bfb	118	switch (message)
c906108c	119	{
dfcd3bfb JM	120	case RDP_Start:
	121	/* Open and/or Initialise */
	122	BAG_newbag ();
	123
	124	MYread_char (mumkid[0], &c); /* type */
	125	MYread_word (mumkid[0], &x); /* memorysize */
	126	if (c & 0x2)
	127	MYread_char (mumkid[0], &d); /* speed */
	128	config.processor = 0;
	129	config.memorysize = x;
	130	config.bytesex = (c & 0x4) ? RDISex_Big : RDISex_Little;
	131	if (c & 0x8)
	132	config.bytesex = RDISex_DontCare;
	133
	134	hostif.dbgprint = myprint;
	135	hostif.dbgpause = mypause;
	136	hostif.dbgarg = stdout;
	137	hostif.writec = mywritec;
	138	hostif.readc = myreadc;
	139	hostif.write = mywrite;
	140	hostif.gets = mygets;
	141	hostif.reset = mypause; /* do nothing */
	142	hostif.resetarg = "Do I love resetting or what!\n";
	143
	144	if (rdi_state)
	145	{
	146	/* we have restarted, so kill off the existing run. */
	147	/* armul_rdi.close(); */
	148	}
	149	i = armul_rdi.open (c & 0x3, &config, &hostif, MCState);
	150	rdi_state = 1;
	151
c906108c	152	MYwrite_char (kidmum[1], RDP_Return);
c906108c	153	MYwrite_char (kidmum[1], (unsigned char) i);
dfcd3bfb JM	154
	155	x = ~0x4;
	156	armul_rdi.info (RDIVector_Catch, &x, 0);
	157
c906108c SS	158	break;
c906108c SS	159
dfcd3bfb JM	160	case RDP_End:
	161	/* Close and Finalise */
	162	i = armul_rdi.close ();
	163	rdi_state = 0;
c906108c SS	164	MYwrite_char (kidmum[1], RDP_Return);
	165	MYwrite_char (kidmum[1], (unsigned char) i);
	166	break;
	167
dfcd3bfb JM	168	case RDP_Read:
	169	/* Read Memory Address */
	170	MYread_word (mumkid[0], &x); /* address */
	171	MYread_word (mumkid[0], &y); /* nbytes */
	172	p = (char *) malloc (y);
	173	i = armul_rdi.read (x, p, (unsigned *) &y);
c906108c	174	MYwrite_char (kidmum[1], RDP_Return);
dfcd3bfb JM	175	for (k = 0; k < y; k++)
	176	MYwrite_char (kidmum[1], p[k]);
	177	free (p);
c906108c	178	MYwrite_char (kidmum[1], (unsigned char) i);
dfcd3bfb JM	179	if (i)
dfcd3bfb JM	180	MYwrite_word (kidmum[1], y); /* number of bytes sent without error */
c906108c SS	181	break;
c906108c SS	182
dfcd3bfb JM	183	case RDP_Write:
	184	/* Write Memory Address */
	185	MYread_word (mumkid[0], &x); /* address */
	186	MYread_word (mumkid[0], &y); /* nbytes */
	187	p = (char *) malloc (y);
	188	for (k = 0; k < y; k++)
	189	MYread_char (mumkid[0], &p[k]);
	190	i = armul_rdi.write (p, x, (unsigned *) &y);
	191	free (p);
c906108c	192	MYwrite_char (kidmum[1], RDP_Return);
c906108c	193	MYwrite_char (kidmum[1], (unsigned char) i);
dfcd3bfb JM	194	if (i)
dfcd3bfb JM	195	MYwrite_word (kidmum[1], y); /* number of bytes sent without error */
c906108c SS	196	break;
c906108c SS	197
dfcd3bfb JM	198	case RDP_CPUread:
	199	/* Read CPU State */
	200	MYread_char (mumkid[0], &c); /* mode */
	201	MYread_word (mumkid[0], &x); /* mask */
	202	p = (char ) malloc (4 RDINumCPURegs);
	203	i = armul_rdi.CPUread (c, x, (ARMword *) p);
c906108c	204	MYwrite_char (kidmum[1], RDP_Return);
dfcd3bfb JM	205	for (k = 1, j = 0; k != 0x80000000; k *= 2)
	206	if (k & x)
	207	MYwrite_word (kidmum[1], ((ARMword *) p)[j++]);
	208	free (p);
	209	if (i)
	210	MYwrite_char (kidmum[1], (unsigned char) j);
	211	MYwrite_char (kidmum[1], (unsigned char) i);
c906108c SS	212	break;
c906108c SS	213
dfcd3bfb JM	214	case RDP_CPUwrite:
	215	/* Write CPU State */
	216	MYread_char (mumkid[0], &c); /* mode */
	217	MYread_word (mumkid[0], &x); /* mask */
	218
	219	p = (char ) malloc (4 RDINumCPURegs);
	220	for (k = 1, j = 0; k != 0x80000000; k *= 2)
	221	if (k & x)
	222	MYread_word (mumkid[0], &(((ARMword *) p)[j++]));
	223	i = armul_rdi.CPUwrite (c, x, (ARMword *) p);
c906108c	224	MYwrite_char (kidmum[1], RDP_Return);
c906108c	225	MYwrite_char (kidmum[1], (unsigned char) i);
dfcd3bfb	226	free (p);
c906108c SS	227	break;
c906108c SS	228
dfcd3bfb JM	229	case RDP_CPread:
	230	/* Read Co-Processor State */
	231	MYread_char (mumkid[0], &c); /* CPnum */
	232	MYread_word (mumkid[0], &x); /* mask */
	233	p = q = (char ) malloc (16 RDINumCPRegs);
	234	i = armul_rdi.CPread (c, x, (ARMword *) p);
	235	MYwrite_char (kidmum[1], RDP_Return);
	236	for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
	237	if (k & x)
	238	{
	239	if ((c == 1 \|\| c == 2) && k <= 128)
	240	{
	241	MYwrite_FPword (kidmum[1], q);
	242	q += 16;
	243	}
	244	else
	245	{
	246	MYwrite_word (kidmum[1], *q);
	247	q += 4;
	248	}
	249	}
	250	free (p);
	251	if (i)
	252	MYwrite_char (kidmum[1], (unsigned char) j);
	253	MYwrite_char (kidmum[1], (unsigned char) i);
	254	break;
	255
	256	case RDP_CPwrite:
	257	/* Write Co-Processor State */
	258	MYread_char (mumkid[0], &c); /* CPnum */
	259	MYread_word (mumkid[0], &x); /* mask */
	260	p = q = (char ) malloc (16 RDINumCPURegs);
	261	for (k = 1, j = 0; k != 0x80000000; k *= 2, j++)
	262	if (k & x)
	263	{
	264	if ((c == 1 \|\| c == 2) && k <= 128)
	265	{
	266	MYread_FPword (kidmum[1], q);
	267	q += 16;
	268	}
	269	else
	270	{
	271	MYread_word (mumkid[0], (ARMword *) q);
	272	q += 4;
	273	}
	274	}
	275	i = armul_rdi.CPwrite (c, x, (ARMword *) p);
	276	MYwrite_char (kidmum[1], RDP_Return);
	277	MYwrite_char (kidmum[1], (unsigned char) i);
	278	free (p);
	279	break;
	280
	281	case RDP_SetBreak:
	282	/* Set Breakpoint */
	283	MYread_word (mumkid[0], &x); /* address */
	284	MYread_char (mumkid[0], &c); /* type */
	285	if ((c & 0xf) >= 5)
	286	MYread_word (mumkid[0], &y); /* bound */
	287	i = armul_rdi.setbreak (x, c, y, &point);
	288	if (!MYrdp_level)
	289	BAG_putpair ((long) x, (long) point);
	290	MYwrite_char (kidmum[1], RDP_Return);
	291	if (MYrdp_level)
	292	MYwrite_word (kidmum[1], point);
293	MYwrite_char (kidmum[1], (unsigned char) i);
294	break;
295
296	case RDP_ClearBreak:
297	/* Clear Breakpoint */
298	MYread_word (mumkid[0], &point); /* PointHandle */
299	if (!MYrdp_level)
300	{
301	BAG_getsecond ((long) point, &outofthebag); /* swap pointhandle for address */
302	BAG_killpair_byfirst (outofthebag);
303	point = outofthebag;
304	}
305	i = armul_rdi.clearbreak (point);
306	MYwrite_char (kidmum[1], RDP_Return);
307	MYwrite_char (kidmum[1], (unsigned char) i);
308	break;
309
310	case RDP_SetWatch:
311	/* Set Watchpoint */
312	MYread_word (mumkid[0], &x); /* address */
313	MYread_char (mumkid[0], &c); /* type */
314	MYread_char (mumkid[0], &d); /* datatype */
315	if ((c & 0xf) >= 5)
316	MYread_word (mumkid[0], &y); /* bound */
317	i = armul_rdi.setwatch (x, c, d, y, &point);
318	MYwrite_char (kidmum[1], RDP_Return);
319	MYwrite_word (kidmum[1], point);
320	MYwrite_char (kidmum[1], (unsigned char) i);
321	break;
322
323	case RDP_ClearWatch:
324	/* Clear Watchpoint */
325	MYread_word (mumkid[0], &point); /* PointHandle */
326	i = armul_rdi.clearwatch (point);
327	MYwrite_char (kidmum[1], RDP_Return);
328	MYwrite_char (kidmum[1], (unsigned char) i);
329	break;
330
331	case RDP_Execute:
332	/* Excecute */
333
334	MYread_char (mumkid[0], &c); /* return */
335
336	#ifdef DEBUG
337	fprintf (stderr, "Starting execution\n");
338	#endif
339	i = armul_rdi.execute (&point);
340	#ifdef DEBUG
341	fprintf (stderr, "Completed execution\n");
342	#endif
343	MYwrite_char (kidmum[1], RDP_Return);
344	if (c & 0x80)
345	MYwrite_word (kidmum[1], point);
346	MYwrite_char (kidmum[1], (unsigned char) i);
347	break;
348
349	case RDP_Step:
350	/* Step */
351	MYread_char (mumkid[0], &c); /* return */
352	MYread_word (mumkid[0], &x); /* ninstr */
353	point = 0x87654321;
354	i = armul_rdi.step (x, &point);
355	MYwrite_char (kidmum[1], RDP_Return);
356	if (c & 0x80)
357	MYwrite_word (kidmum[1], point);
358	MYwrite_char (kidmum[1], (unsigned char) i);
359	break;
360
361	case RDP_Info:
362	/* Info */
363	MYread_word (mumkid[0], &x);
364	switch (x)
365	{
366	case RDIInfo_Target:
367	i = armul_rdi.info (RDIInfo_Target, &y, &z);
368	MYwrite_char (kidmum[1], RDP_Return);
369	MYwrite_word (kidmum[1], y); /* Loads of info... */
370	MYwrite_word (kidmum[1], z); /* Model */
371	MYwrite_char (kidmum[1], (unsigned char) i);
372	break;
373
374	case RDISet_RDILevel:
375	MYread_word (mumkid[0], &x); /* arg1, debug level */
376	i = armul_rdi.info (RDISet_RDILevel, &x, 0);
377	if (i == RDIError_NoError)
378	MYrdp_level = x;
379	MYwrite_char (kidmum[1], RDP_Return);
380	MYwrite_char (kidmum[1], (unsigned char) i);
381	break;
382
383	case RDISet_Cmdline:
384	for (p = command_line; MYread_char (mumkid[0], p), *p; p++)
385	; /* String */
386	i = armul_rdi.info (RDISet_Cmdline,
387	(unsigned long *) command_line, 0);
388	MYwrite_char (kidmum[1], RDP_Return);
389	MYwrite_char (kidmum[1], (unsigned char) i);
390	break;
391
392	case RDIInfo_Step:
393	i = armul_rdi.info (RDIInfo_Step, &x, 0);
394	MYwrite_char (kidmum[1], RDP_Return);
395	MYwrite_word (kidmum[1], x);
396	MYwrite_char (kidmum[1], (unsigned char) i);
397	break;
398
399	case RDIVector_Catch:
400	MYread_word (mumkid[0], &x);
401	i = armul_rdi.info (RDIVector_Catch, &x, 0);
402	MYwrite_char (kidmum[1], RDP_Return);
403	MYwrite_char (kidmum[1], i);
404	break;
405
406	case RDIInfo_Points:
407	i = armul_rdi.info (RDIInfo_Points, &x, 0);
408	MYwrite_char (kidmum[1], RDP_Return);
409	MYwrite_word (kidmum[1], x);
410	MYwrite_char (kidmum[1], (unsigned char) i);
411	break;
412
413	default:
414	fprintf (stderr, "Unsupported info code %d\n", x);
415	break;
416	}
417	break;
418
419	case RDP_OSOpReply:
420	/* OS Operation Reply */
421	MYwrite_char (kidmum[1], RDP_Fatal);
422	break;
423
424	case RDP_Reset:
425	/* Reset */
426	for (i = 0; i < 50; i++)
427	MYwrite_char (kidmum[1], RDP_Reset);
428	p = (char *) malloc (MAXHOSTNAMELENGTH + 5 + 20);
429	sprintf (p, "Running on %s:%d\n", localhost, socketnumber);
430	MYwrite_string (kidmum[1], p);
431	free (p);
432
433	break;
c906108c	434	default:
dfcd3bfb JM	435	fprintf (stderr, "Oh dear: Something is seriously wrong :-(\n");
dfcd3bfb JM	436	/* Hmm.. bad RDP operation */
c906108c SS	437	break;
c906108c SS	438	}
c906108c	439	}
c906108c SS	440	}
	441
	442
	443	/* Handles memory read operations until an OS Operation Reply Message is */
	444	/* encounterd. It then returns the byte info value (0, 1, or 2) and fills */
	445	/* in 'putinr0' with the data if appropriate. */
dfcd3bfb JM	446	int
dfcd3bfb JM	447	wait_for_osreply (ARMword * reply)
c906108c SS	448	{
	449	char p, q;
	450	int i, j, k;
	451	unsigned char c, d, message;
	452	ARMword x, y, z;
	453	struct sigaction action;
	454	PointHandle point;
	455	Dbg_ConfigBlock config;
	456	Dbg_HostosInterface hostif;
	457	struct Dbg_MCState *MCState;
	458	char command_line[256];
	459	struct fd_set readfds;
dfcd3bfb	460
c906108c	461	#ifdef DEBUG
dfcd3bfb	462	fprintf (stderr, "wait_for_osreply ().\n");
c906108c SS	463	#endif
	464
	465	/* Setup a signal handler for SIGUSR1 */
	466	action.sa_handler = kid_handlesignal;
	467	action.sa_mask = 0;
	468	action.sa_flags = 0;
dfcd3bfb JM	469
	470	sigaction (SIGUSR1, &action, (struct sigaction *) 0);
	471
c906108c	472	while (1)
dfcd3bfb JM	473	{
	474	/* Wait for ever */
	475	FD_ZERO (&readfds);
	476	FD_SET (mumkid[0], &readfds);
	477
	478	i = select (nfds, &readfds,
	479	(fd_set ) 0, (fd_set ) 0, (struct timeval *) 0);
	480
	481	if (i < 0)
	482	{
	483	perror ("select");
	484	}
	485
	486	if (read (mumkid[0], &message, 1) < 1)
	487	{
	488	perror ("read");
	489	}
	490
	491	switch (message)
	492	{
	493	case RDP_Read:
	494	/* Read Memory Address */
	495	MYread_word (mumkid[0], &x); /* address */
	496	MYread_word (mumkid[0], &y); /* nbytes */
	497	p = (char *) malloc (y);
	498	i = armul_rdi.read (x, p, (unsigned *) &y);
	499	MYwrite_char (kidmum[1], RDP_Return);
	500	for (k = 0; k < y; k++)
	501	MYwrite_char (kidmum[1], p[k]);
	502	free (p);
	503	MYwrite_char (kidmum[1], (unsigned char) i);
	504	if (i)
	505	MYwrite_word (kidmum[1], y); /* number of bytes sent without error */
	506	break;
	507
	508	case RDP_Write:
	509	/* Write Memory Address */
	510	MYread_word (mumkid[0], &x); /* address */
	511	MYread_word (mumkid[0], &y); /* nbytes */
	512	p = (char *) malloc (y);
	513	for (k = 0; k < y; k++)
	514	MYread_char (mumkid[0], &p[k]);
	515	i = armul_rdi.write (p, x, (unsigned *) &y);
	516	free (p);
	517	MYwrite_char (kidmum[1], RDP_Return);
	518	MYwrite_char (kidmum[1], (unsigned char) i);
	519	if (i)
	520	MYwrite_word (kidmum[1], y); /* number of bytes sent without error */
	521	break;
	522
	523	case RDP_OSOpReply:
	524	/* OS Operation Reply */
	525	MYread_char (mumkid[0], &c);
	526	if (c == 1)
	527	MYread_char (mumkid[0], (char *) reply);
	528	if (c == 2)
	529	MYread_word (mumkid[0], reply);
	530	return c;
	531	break;
	532
	533	default:
	534	fprintf (stderr,
	535	"HELP! Unaccounted-for message during OS request. \n");
	536	MYwrite_char (kidmum[1], RDP_Fatal);
537	}
c906108c	538	}
c906108c	539	}