Wed May 24 14:37:31 1995 Steve Chamberlain <sac@slash.cygnus.com>

	* New.

1 files changed, 510 insertions, 0 deletions

diff --git a/sim/arm/kid.c b/sim/arm/kid.c
new file mode 100644
index 0000000000..7a0a5210ff
--- /dev/null
+++ b/sim/arm/kid.c
@@ -0,0 +1,510 @@
+/*  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 2 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, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+/*****************************************************************/
+/* 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);
+    }
+  }
+}