This commit was manufactured by cvs2svn to create branch

[thirdparty/binutils-gdb.git] / sim / arm / armrdi.c

/*  armrdi.c -- ARMulator 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */

#include <string.h>
#include <ctype.h>
#include "armdefs.h"
#include "armemu.h"
#include "armos.h"
#include "dbg_cp.h"
#include "dbg_conf.h"
#include "dbg_rdi.h"
#include "dbg_hif.h"
#include "communicate.h"

/***************************************************************************\
*                               Declarations                                *
\***************************************************************************/

#define Watch_AnyRead (RDIWatch_ByteRead+RDIWatch_HalfRead+RDIWatch_WordRead)
#define Watch_AnyWrite (RDIWatch_ByteWrite+RDIWatch_HalfWrite+RDIWatch_WordWrite)

static unsigned FPRegsAddr;     /* last known address of FPE regs */
#define FPESTART 0x2000L
#define FPEEND   0x8000L

#define IGNORE(d) (d = d)
#ifdef RDI_VERBOSE
#define TracePrint(s) \
 if (rdi_log & 1) ARMul_DebugPrint s
#else
#define TracePrint(s)
#endif

static ARMul_State *state = NULL;
static unsigned BreaksSet;      /* The number of breakpoints set */

static int rdi_log = 0;         /* debugging  ? */

#define LOWEST_RDI_LEVEL 0
#define HIGHEST_RDI_LEVEL 1
static int MYrdi_level = LOWEST_RDI_LEVEL;

typedef struct BreakNode BreakNode;
typedef struct WatchNode WatchNode;

struct BreakNode
{                               /* A breakpoint list node */
  BreakNode *next;
  ARMword address;              /* The address of this breakpoint */
  unsigned type;                /* The type of comparison */
  ARMword bound;                /* The other address for a range */
  ARMword inst;
};

struct WatchNode
{                               /* A watchpoint list node */
  WatchNode *next;
  ARMword address;              /* The address of this watchpoint */
  unsigned type;                /* The type of comparison */
  unsigned datatype;            /* The type of access to watch for */
  ARMword bound;                /* The other address for a range */
};

BreakNode *BreakList = NULL;
WatchNode *WatchList = NULL;

void
ARMul_DebugPrint_i (const Dbg_HostosInterface * hostif, const char *format,
                    ...)
{
  va_list ap;
  va_start (ap, format);
  hostif->dbgprint (hostif->dbgarg, format, ap);
  va_end (ap);
}

void
ARMul_DebugPrint (ARMul_State * state, const char *format, ...)
{
  va_list ap;
  va_start (ap, format);
  if (!(rdi_log & 8))
    state->hostif->dbgprint (state->hostif->dbgarg, format, ap);
  va_end (ap);
}

#define CONSOLE_PRINT_MAX_LEN 128

void
ARMul_ConsolePrint (ARMul_State * state, const char *format, ...)
{
  va_list ap;
  int ch;
  char *str, buf[CONSOLE_PRINT_MAX_LEN];
  int i, j;
  ARMword junk;

  va_start (ap, format);
  vsprintf (buf, format, ap);

  for (i = 0; buf[i]; i++);     /* The string is i chars long */

  str = buf;
  while (i >= 32)
    {
      MYwrite_char (kidmum[1], RDP_OSOp);
      MYwrite_word (kidmum[1], SWI_Write0);
      MYwrite_char (kidmum[1], OS_SendString);
      MYwrite_char (kidmum[1], 32);     /* Send string 32bytes at a time */
      for (j = 0; j < 32; j++, str++)
        MYwrite_char (kidmum[1], *str);
      wait_for_osreply (&junk);
      i -= 32;
    }

  if (i > 0)
    {
      MYwrite_char (kidmum[1], RDP_OSOp);
      MYwrite_word (kidmum[1], SWI_Write0);
      MYwrite_char (kidmum[1], OS_SendString);
      MYwrite_char (kidmum[1], (unsigned char) i);      /* Send remainder of string  */
      for (j = 0; j < i; j++, str++)
        MYwrite_char (kidmum[1], *str);
      wait_for_osreply (&junk);
    }

  va_end (ap);
  return;

/*   str = buf; */
/*   while ((ch=*str++) != 0) */
/*     state->hostif->writec(state->hostif->hostosarg, ch); */
}

void
ARMul_DebugPause (ARMul_State * state)
{
  if (!(rdi_log & 8))
    state->hostif->dbgpause (state->hostif->dbgarg);
}

/***************************************************************************\
*                                 RDI_open                                  *
\***************************************************************************/

static void
InitFail (int exitcode, char const *which)
{
  ARMul_ConsolePrint (state, "%s interface failed to initialise. Exiting\n",
                      which);
  exit (exitcode);
}

static void
RDIInit (unsigned type)
{
  if (type == 0)
    {                           /* cold start */
      state->CallDebug = state->MemReadDebug = state->MemWriteDebug = 0;
      BreaksSet = 0;
    }
}

#define UNKNOWNPROC 0

typedef struct
{
  char name[16];
  unsigned properties;
}
Processor;

Processor const p_arm2 =    { "ARM2",   ARM_Fix26_Prop };
Processor const p_arm2as =  { "ARM2AS", ARM_Fix26_Prop };
Processor const p_arm61 =   { "ARM61",  ARM_Fix26_Prop };
Processor const p_arm3 =    { "ARM3",   ARM_Fix26_Prop };
Processor const p_arm6 =    { "ARM6",   ARM_Lock_Prop };
Processor const p_arm60 =   {  "ARM60", ARM_Lock_Prop };
Processor const p_arm600 =  { "ARM600", ARM_Lock_Prop };
Processor const p_arm610 =  { "ARM610", ARM_Lock_Prop };
Processor const p_arm620 =  { "ARM620", ARM_Lock_Prop };
Processor const p_unknown = { "",       0 };

Processor const *const processors[] =
{
  &p_arm6,                      /* default: must come first */
  &p_arm2,
  &p_arm2as,
  &p_arm61,
  &p_arm3,
  &p_arm60,
  &p_arm600,
  &p_arm610,
  &p_arm620,
  &p_unknown
};

typedef struct ProcessorConfig ProcessorConfig;
struct ProcessorConfig
{
  long id[2];
  ProcessorConfig const *self;
  long count;
  Processor const *const *processors;
};

ProcessorConfig const processorconfig = {
  {((((((long) 'x' << 8) | ' ') << 8) | 'c') << 8) | 'p',
   ((((((long) 'u' << 8) | 's') << 8) | ' ') << 8) | 'x'},
  &processorconfig,
  16,
  processors
};

static int
RDI_open (unsigned type, const Dbg_ConfigBlock * config,
          const Dbg_HostosInterface * hostif, struct Dbg_MCState *dbg_state)
/* Initialise everything */
{
  int virgin = (state == NULL);
  IGNORE (dbg_state);

#ifdef RDI_VERBOSE
  if (rdi_log & 1)
    {
      if (virgin)
        ARMul_DebugPrint_i (hostif, "RDI_open: type = %d\n", type);
      else
        ARMul_DebugPrint (state, "RDI_open: type = %d\n", type);
    }
#endif

  if (type & 1)
    {                           /* Warm start */
      ARMul_Reset (state);
      RDIInit (1);
    }
  else
    {
      if (virgin)
        {
          ARMul_EmulateInit ();
          state = ARMul_NewState ();
          state->hostif = hostif;
          {
            int req = config->processor;
            unsigned processor = processors[req]->val;
            ARMul_SelectProcessor (state, processor);
            ARMul_Reset (state);
            ARMul_ConsolePrint (state, "ARMulator V1.50, %s",
                                processors[req]->name);
          }
          if (ARMul_MemoryInit (state, config->memorysize) == FALSE)
            InitFail (1, "Memory");
          if (config->bytesex != RDISex_DontCare)
            state->bigendSig = config->bytesex;
          if (ARMul_CoProInit (state) == FALSE)
            InitFail (2, "Co-Processor");
          if (ARMul_OSInit (state) == FALSE)
            InitFail (3, "Operating System");
        }
      ARMul_Reset (state);
      RDIInit (0);
    }
  if (type & 2)
    {                           /* Reset the comms link */
      /* what comms link ? */
    }
  if (virgin && (type & 1) == 0)        /* Cold start */
    ARMul_ConsolePrint (state, ", %s endian.\n",
                        state->bigendSig ? "Big" : "Little");

  if (config->bytesex == RDISex_DontCare)
    return (state->bigendSig ? RDIError_BigEndian : RDIError_LittleEndian);
  else
    return (RDIError_NoError);
}

/***************************************************************************\
*                                RDI_close                                  *
\***************************************************************************/

static int
RDI_close (void)
{
  TracePrint ((state, "RDI_close\n"));
  ARMul_OSExit (state);
  ARMul_CoProExit (state);
  ARMul_MemoryExit (state);
  return (RDIError_NoError);
}

/***************************************************************************\
*                                 RDI_read                                  *
\***************************************************************************/

static int
RDI_read (ARMword source, void *dest, unsigned *nbytes)
{
  unsigned i;
  char *memptr = (char *) dest;

  TracePrint ((state, "RDI_read: source=%.8lx dest=%p nbytes=%.8x\n",
               source, dest, *nbytes));

  for (i = 0; i < *nbytes; i++)
    *memptr++ = (char) ARMul_ReadByte (state, source++);
  if (state->abortSig)
    {
      state->abortSig = LOW;
      return (RDIError_DataAbort);
    }
  return (RDIError_NoError);
}

/***************************************************************************\
*                                  RDI_write                                *
\***************************************************************************/

static int
RDI_write (const void *source, ARMword dest, unsigned *nbytes)
{
  unsigned i;
  char *memptr = (char *) source;

  TracePrint ((state, "RDI_write: source=%p dest=%.8lx nbytes=%.8x\n",
               source, dest, *nbytes));

  for (i = 0; i < *nbytes; i++)
    ARMul_WriteByte (state, (ARMword) dest++, (ARMword) * memptr++);

  if (state->abortSig)
    {
      state->abortSig = LOW;
      return (RDIError_DataAbort);
    }
  return (RDIError_NoError);
}

/***************************************************************************\
*                                RDI_CPUread                                *
\***************************************************************************/

static int
RDI_CPUread (unsigned mode, unsigned long mask, ARMword buffer[])
{
  unsigned i, upto;

  if (mode == RDIMode_Curr)
    mode = (unsigned) (ARMul_GetCPSR (state) & MODEBITS);

  for (upto = 0, i = 0; i < 15; i++)
    if (mask & (1L << i))
      {
        buffer[upto++] = ARMul_GetReg (state, mode, i);
      }

  if (mask & RDIReg_R15)
    {
      buffer[upto++] = ARMul_GetR15 (state);
    }

  if (mask & RDIReg_PC)
    {
      buffer[upto++] = ARMul_GetPC (state);
    }

  if (mask & RDIReg_CPSR)
    buffer[upto++] = ARMul_GetCPSR (state);

  if (mask & RDIReg_SPSR)
    buffer[upto++] = ARMul_GetSPSR (state, mode);

  TracePrint ((state, "RDI_CPUread: mode=%.8x mask=%.8lx", mode, mask));
#ifdef RDI_VERBOSE
  if (rdi_log & 1)
    {
      for (upto = 0, i = 0; i <= 20; i++)
        if (mask & (1L << i))
          {
            ARMul_DebugPrint (state, "%c%.8lx", upto % 4 == 0 ? '\n' : ' ',
                              buffer[upto]);
            upto++;
          }
      ARMul_DebugPrint (state, "\n");
    }
#endif

  return (RDIError_NoError);
}

/***************************************************************************\
*                               RDI_CPUwrite                                *
\***************************************************************************/

static int
RDI_CPUwrite (unsigned mode, unsigned long mask, ARMword const buffer[])
{
  int i, upto;


  TracePrint ((state, "RDI_CPUwrite: mode=%.8x mask=%.8lx", mode, mask));
#ifdef RDI_VERBOSE
  if (rdi_log & 1)
    {
      for (upto = 0, i = 0; i <= 20; i++)
        if (mask & (1L << i))
          {
            ARMul_DebugPrint (state, "%c%.8lx", upto % 4 == 0 ? '\n' : ' ',
                              buffer[upto]);
            upto++;
          }
      ARMul_DebugPrint (state, "\n");
    }
#endif

  if (mode == RDIMode_Curr)
    mode = (unsigned) (ARMul_GetCPSR (state) & MODEBITS);

  for (upto = 0, i = 0; i < 15; i++)
    if (mask & (1L << i))
      ARMul_SetReg (state, mode, i, buffer[upto++]);

  if (mask & RDIReg_R15)
    ARMul_SetR15 (state, buffer[upto++]);

  if (mask & RDIReg_PC)
    {

      ARMul_SetPC (state, buffer[upto++]);
    }
  if (mask & RDIReg_CPSR)
    ARMul_SetCPSR (state, buffer[upto++]);

  if (mask & RDIReg_SPSR)
    ARMul_SetSPSR (state, mode, buffer[upto++]);

  return (RDIError_NoError);
}

/***************************************************************************\
*                                RDI_CPread                                 *
\***************************************************************************/

static int
RDI_CPread (unsigned CPnum, unsigned long mask, ARMword buffer[])
{
  ARMword fpregsaddr, word[4];

  unsigned r, w;
  unsigned upto;

  if (CPnum != 1 && CPnum != 2)
    {
      unsigned char const *rmap = state->CPRegWords[CPnum];
      if (rmap == NULL)
        return (RDIError_UnknownCoPro);
      for (upto = 0, r = 0; r < rmap[-1]; r++)
        if (mask & (1L << r))
          {
            (void) state->CPRead[CPnum] (state, r, &buffer[upto]);
            upto += rmap[r];
          }
      TracePrint ((state, "RDI_CPread: CPnum=%d mask=%.8lx", CPnum, mask));
#ifdef RDI_VERBOSE
      if (rdi_log & 1)
        {
          w = 0;
          for (upto = 0, r = 0; r < rmap[-1]; r++)
            if (mask & (1L << r))
              {
                int words = rmap[r];
                ARMul_DebugPrint (state, "%c%2d",
                                  (w >= 4 ? (w = 0, '\n') : ' '), r);
                while (--words >= 0)
                  {
                    ARMul_DebugPrint (state, " %.8lx", buffer[upto++]);
                    w++;
                  }
              }
          ARMul_DebugPrint (state, "\n");
        }
#endif
      return RDIError_NoError;
    }

#ifdef NOFPE
  return RDIError_UnknownCoPro;

#else
  if (FPRegsAddr == 0)
    {
      fpregsaddr = ARMul_ReadWord (state, 4L);
      if ((fpregsaddr & 0xff800000) != 0xea000000)      /* Must be a forward branch */
        return RDIError_UnknownCoPro;
      fpregsaddr = ((fpregsaddr & 0xffffff) << 2) + 8;  /* address in __fp_decode - 4 */
      if ((fpregsaddr < FPESTART) || (fpregsaddr >= FPEEND))
        return RDIError_UnknownCoPro;
      fpregsaddr = ARMul_ReadWord (state, fpregsaddr);  /* pointer to fp registers */
      FPRegsAddr = fpregsaddr;
    }
  else
    fpregsaddr = FPRegsAddr;

  if (fpregsaddr == 0)
    return RDIError_UnknownCoPro;
  for (upto = 0, r = 0; r < 8; r++)
    if (mask & (1L << r))
      {
        for (w = 0; w < 4; w++)
          word[w] =
            ARMul_ReadWord (state,
                            fpregsaddr + (ARMword) r * 16 + (ARMword) w * 4);
        switch ((int) (word[3] >> 29))
          {
          case 0:
          case 2:
          case 4:
          case 6:               /* its unpacked, convert to extended */
            buffer[upto++] = 2; /* mark as extended */
            buffer[upto++] = (word[3] & 0x7fff) | (word[0] & 0x80000000);       /* exp and sign */
            buffer[upto++] = word[1];   /* mantissa 1 */
            buffer[upto++] = word[2];   /* mantissa 2 */
            break;
          case 1:               /* packed single */
            buffer[upto++] = 0; /* mark as single */
            buffer[upto++] = word[0];   /* sign, exp and mantissa */
            buffer[upto++] = word[1];   /* padding */
            buffer[upto++] = word[2];   /* padding */
            break;
          case 3:               /* packed double */
            buffer[upto++] = 1; /* mark as double */
            buffer[upto++] = word[0];   /* sign, exp and mantissa1 */
            buffer[upto++] = word[1];   /* mantissa 2 */
            buffer[upto++] = word[2];   /* padding */
            break;
          case 5:               /* packed extended */
            buffer[upto++] = 2; /* mark as extended */
            buffer[upto++] = word[0];   /* sign and exp */
            buffer[upto++] = word[1];   /* mantissa 1 */
            buffer[upto++] = word[2];   /* mantissa 2 */
            break;
          case 7:               /* packed decimal */
            buffer[upto++] = 3; /* mark as packed decimal */
            buffer[upto++] = word[0];   /* sign, exp and mantissa1 */
            buffer[upto++] = word[1];   /* mantissa 2 */
            buffer[upto++] = word[2];   /* mantissa 3 */
            break;
          }
      }
  if (mask & (1L << r))
    buffer[upto++] = ARMul_ReadWord (state, fpregsaddr + 128);  /* fpsr */
  if (mask & (1L << (r + 1)))
    buffer[upto++] = 0;         /* fpcr */

  TracePrint ((state, "RDI_CPread: CPnum=%d mask=%.8lx\n", CPnum, mask));
#ifdef RDI_VERBOSE
  if (rdi_log & 1)
    {
      for (upto = 0, r = 0; r < 9; r++)
        if (mask & (1L << r))
          {
            if (r != 8)
              {
                ARMul_DebugPrint (state, "%08lx ", buffer[upto++]);
                ARMul_DebugPrint (state, "%08lx ", buffer[upto++]);
                ARMul_DebugPrint (state, "%08lx ", buffer[upto++]);
              }
            ARMul_DebugPrint (state, "%08lx\n", buffer[upto++]);
          }
      ARMul_DebugPrint (state, "\n");
    }
#endif
  return (RDIError_NoError);
#endif /* NOFPE */
}

/***************************************************************************\
*                               RDI_CPwrite                                 *
\***************************************************************************/

static int
RDI_CPwrite (unsigned CPnum, unsigned long mask, ARMword const buffer[])
{
  unsigned r;
  unsigned upto;
  ARMword fpregsaddr;

  if (CPnum != 1 && CPnum != 2)
    {
      unsigned char const *rmap = state->CPRegWords[CPnum];
      if (rmap == NULL)
        return (RDIError_UnknownCoPro);
      TracePrint ((state, "RDI_CPwrite: CPnum=%d mask=%.8lx", CPnum, mask));
#ifdef RDI_VERBOSE
      if (rdi_log & 1)
        {
          int w = 0;
          for (upto = 0, r = 0; r < rmap[-1]; r++)
            if (mask & (1L << r))
              {
                int words = rmap[r];
                ARMul_DebugPrint (state, "%c%2d",
                                  (w >= 4 ? (w = 0, '\n') : ' '), r);
                while (--words >= 0)
                  {
                    ARMul_DebugPrint (state, " %.8lx", buffer[upto++]);
                    w++;
                  }
              }
          ARMul_DebugPrint (state, "\n");
        }
#endif
      for (upto = 0, r = 0; r < rmap[-1]; r++)
        if (mask & (1L << r))
          {
            (void) state->CPWrite[CPnum] (state, r, &buffer[upto]);
            upto += rmap[r];
          }
      return RDIError_NoError;
    }

#ifdef NOFPE
  return RDIError_UnknownCoPro;

#else
  TracePrint ((state, "RDI_CPwrite: CPnum=%d mask=%.8lx", CPnum, mask));
#ifdef RDI_VERBOSE
  if (rdi_log & 1)
    {
      for (upto = 0, r = 0; r < 9; r++)
        if (mask & (1L << r))
          {
            if (r != 8)
              {
                ARMul_DebugPrint (state, "%08lx ", buffer[upto++]);
                ARMul_DebugPrint (state, "%08lx ", buffer[upto++]);
                ARMul_DebugPrint (state, "%08lx ", buffer[upto++]);
              }
            ARMul_DebugPrint (state, "%08lx\n", buffer[upto++]);
          }
      ARMul_DebugPrint (state, "\n");
    }
#endif

  if (FPRegsAddr == 0)
    {
      fpregsaddr = ARMul_ReadWord (state, 4L);
      if ((fpregsaddr & 0xff800000) != 0xea000000)      /* Must be a forward branch */
        return RDIError_UnknownCoPro;
      fpregsaddr = ((fpregsaddr & 0xffffff) << 2) + 8;  /* address in __fp_decode - 4 */
      if ((fpregsaddr < FPESTART) || (fpregsaddr >= FPEEND))
        return RDIError_UnknownCoPro;
      fpregsaddr = ARMul_ReadWord (state, fpregsaddr);  /* pointer to fp registers */
      FPRegsAddr = fpregsaddr;
    }
  else
    fpregsaddr = FPRegsAddr;

  if (fpregsaddr == 0)
    return RDIError_UnknownCoPro;
  for (upto = 0, r = 0; r < 8; r++)
    if (mask & (1L << r))
      {
        ARMul_WriteWord (state, fpregsaddr + (ARMword) r * 16,
                         buffer[upto + 1]);
        ARMul_WriteWord (state, fpregsaddr + (ARMword) r * 16 + 4,
                         buffer[upto + 2]);
        ARMul_WriteWord (state, fpregsaddr + (ARMword) r * 16 + 8,
                         buffer[upto + 3]);
        ARMul_WriteWord (state, fpregsaddr + (ARMword) r * 16 + 12,
                         (buffer[upto] * 2 + 1) << 29); /* mark type */
        upto += 4;
      }
  if (mask & (1L << r))
    ARMul_WriteWord (state, fpregsaddr + 128, buffer[upto++]);  /* fpsr */
  return (RDIError_NoError);
#endif /* NOFPE */
}

static void
deletebreaknode (BreakNode ** prevp)
{
  BreakNode *p = *prevp;
  *prevp = p->next;
  ARMul_WriteWord (state, p->address, p->inst);
  free ((char *) p);
  BreaksSet--;
  state->CallDebug--;
}

static int
removebreak (ARMword address, unsigned type)
{
  BreakNode *p, **prevp = &BreakList;
  for (; (p = *prevp) != NULL; prevp = &p->next)
    if (p->address == address && p->type == type)
      {
        deletebreaknode (prevp);
        return TRUE;
      }
  return FALSE;
}

/* This routine installs a breakpoint into the breakpoint table */

static BreakNode *
installbreak (ARMword address, unsigned type, ARMword bound)
{
  BreakNode *p = (BreakNode *) malloc (sizeof (BreakNode));
  p->next = BreakList;
  BreakList = p;
  p->address = address;
  p->type = type;
  p->bound = bound;
  p->inst = ARMul_ReadWord (state, address);
  ARMul_WriteWord (state, address, 0xee000000L);
  return p;
}

/***************************************************************************\
*                               RDI_setbreak                                *
\***************************************************************************/

static int
RDI_setbreak (ARMword address, unsigned type, ARMword bound,
              PointHandle * handle)
{
  BreakNode *p;
  TracePrint ((state, "RDI_setbreak: address=%.8lx type=%d bound=%.8lx\n",
               address, type, bound));

  removebreak (address, type);
  p = installbreak (address, type, bound);
  BreaksSet++;
  state->CallDebug++;
  *handle = (PointHandle) p;
  TracePrint ((state, " returns %.8lx\n", *handle));
  return RDIError_NoError;
}

/***************************************************************************\
*                               RDI_clearbreak                              *
\***************************************************************************/

static int
RDI_clearbreak (PointHandle handle)
{
  TracePrint ((state, "RDI_clearbreak: address=%.8lx\n", handle));
  {
    BreakNode *p, **prevp = &BreakList;
    for (; (p = *prevp) != NULL; prevp = &p->next)
      if (p == (BreakNode *) handle)
        break;
    if (p == NULL)
      return RDIError_NoSuchPoint;
    deletebreaknode (prevp);
    return RDIError_NoError;
  }
}

/***************************************************************************\
*            Internal functions for breakpoint table manipulation           *
\***************************************************************************/

static void
deletewatchnode (WatchNode ** prevp)
{
  WatchNode *p = *prevp;
  if (p->datatype & Watch_AnyRead)
    state->MemReadDebug--;
  if (p->datatype & Watch_AnyWrite)
    state->MemWriteDebug--;
  *prevp = p->next;
  free ((char *) p);
}

int
removewatch (ARMword address, unsigned type)
{
  WatchNode *p, **prevp = &WatchList;
  for (; (p = *prevp) != NULL; prevp = &p->next)
    if (p->address == address && p->type == type)
      {                         /* found a match */
        deletewatchnode (prevp);
        return TRUE;
      }
  return FALSE;                 /* never found a match */
}

static WatchNode *
installwatch (ARMword address, unsigned type, unsigned datatype,
              ARMword bound)
{
  WatchNode *p = (WatchNode *) malloc (sizeof (WatchNode));
  p->next = WatchList;
  WatchList = p;
  p->address = address;
  p->type = type;
  p->datatype = datatype;
  p->bound = bound;
  return p;
}

/***************************************************************************\
*                               RDI_setwatch                                *
\***************************************************************************/

static int
RDI_setwatch (ARMword address, unsigned type, unsigned datatype,
              ARMword bound, PointHandle * handle)
{
  WatchNode *p;
  TracePrint (
              (state,
               "RDI_setwatch: address=%.8lx type=%d datatype=%d bound=%.8lx",
               address, type, datatype, bound));

  if (!state->CanWatch)
    return RDIError_UnimplementedMessage;

  removewatch (address, type);
  p = installwatch (address, type, datatype, bound);
  if (datatype & Watch_AnyRead)
    state->MemReadDebug++;
  if (datatype & Watch_AnyWrite)
    state->MemWriteDebug++;
  *handle = (PointHandle) p;
  TracePrint ((state, " returns %.8lx\n", *handle));
  return RDIError_NoError;
}

/***************************************************************************\
*                               RDI_clearwatch                              *
\***************************************************************************/

static int
RDI_clearwatch (PointHandle handle)
{
  TracePrint ((state, "RDI_clearwatch: address=%.8lx\n", handle));
  {
    WatchNode *p, **prevp = &WatchList;
    for (; (p = *prevp) != NULL; prevp = &p->next)
      if (p == (WatchNode *) handle)
        break;
    if (p == NULL)
      return RDIError_NoSuchPoint;
    deletewatchnode (prevp);
    return RDIError_NoError;
  }
}

/***************************************************************************\
*                               RDI_execute                                 *
\***************************************************************************/

static int
RDI_execute (PointHandle * handle)
{
  TracePrint ((state, "RDI_execute\n"));
  if (rdi_log & 4)
    {
      state->CallDebug++;
      state->Debug = TRUE;
    }
  state->EndCondition = RDIError_NoError;
  state->StopHandle = 0;

  ARMul_DoProg (state);

  *handle = state->StopHandle;
  state->Reg[15] -= 8;          /* undo the pipeline */
  if (rdi_log & 4)
    {
      state->CallDebug--;
      state->Debug = FALSE;
    }
  return (state->EndCondition);
}

/***************************************************************************\
*                                RDI_step                                   *
\***************************************************************************/

static int
RDI_step (unsigned ninstr, PointHandle * handle)
{

  TracePrint ((state, "RDI_step\n"));
  if (ninstr != 1)
    return RDIError_UnimplementedMessage;
  if (rdi_log & 4)
    {
      state->CallDebug++;
      state->Debug = TRUE;
    }
  state->EndCondition = RDIError_NoError;
  state->StopHandle = 0;
  ARMul_DoInstr (state);
  *handle = state->StopHandle;
  state->Reg[15] -= 8;          /* undo the pipeline */
  if (rdi_log & 4)
    {
      state->CallDebug--;
      state->Debug = FALSE;
    }
  return (state->EndCondition);
}

/***************************************************************************\
*                               RDI_info                                    *
\***************************************************************************/

static int
RDI_info (unsigned type, ARMword * arg1, ARMword * arg2)
{
  switch (type)
    {
    case RDIInfo_Target:
      TracePrint ((state, "RDI_Info_Target\n"));
      /* Emulator, speed 10**5 IPS */
      *arg1 = 5 | HIGHEST_RDI_LEVEL << 5 | LOWEST_RDI_LEVEL << 8;
      *arg2 = 1298224434;
      return RDIError_NoError;

    case RDIInfo_Points:
      {
        ARMword n = RDIPointCapability_Comparison | RDIPointCapability_Range |
          RDIPointCapability_Mask | RDIPointCapability_Status;
        TracePrint ((state, "RDI_Info_Points\n"));
        if (state->CanWatch)
          n |= (Watch_AnyRead + Watch_AnyWrite) << 2;
        *arg1 = n;
        return RDIError_NoError;
      }

    case RDIInfo_Step:
      TracePrint ((state, "RDI_Info_Step\n"));
      *arg1 = RDIStep_Single;
      return RDIError_NoError;

    case RDIInfo_MMU:
      TracePrint ((state, "RDI_Info_MMU\n"));
      *arg1 = 1313820229;
      return RDIError_NoError;

    case RDISignal_Stop:
      TracePrint ((state, "RDISignal_Stop\n"));
      state->CallDebug++;
      state->EndCondition = RDIError_UserInterrupt;
      return RDIError_NoError;

    case RDIVector_Catch:
      TracePrint ((state, "RDIVector_Catch %.8lx\n", *arg1));
      state->VectorCatch = (unsigned) *arg1;
      return RDIError_NoError;

    case RDISet_Cmdline:
      TracePrint ((state, "RDI_Set_Cmdline %s\n", (char *) arg1));
      state->CommandLine =
        (char *) malloc ((unsigned) strlen ((char *) arg1) + 1);
      (void) strcpy (state->CommandLine, (char *) arg1);
      return RDIError_NoError;

    case RDICycles:
      TracePrint ((state, "RDI_Info_Cycles\n"));
      arg1[0] = 0;
      arg1[1] = state->NumInstrs;
      arg1[2] = 0;
      arg1[3] = state->NumScycles;
      arg1[4] = 0;
      arg1[5] = state->NumNcycles;
      arg1[6] = 0;
      arg1[7] = state->NumIcycles;
      arg1[8] = 0;
      arg1[9] = state->NumCcycles;
      arg1[10] = 0;
      arg1[11] = state->NumFcycles;
      return RDIError_NoError;

    case RDIErrorP:
      *arg1 = ARMul_OSLastErrorP (state);
      TracePrint ((state, "RDI_ErrorP returns %ld\n", *arg1));
      return RDIError_NoError;

    case RDIInfo_DescribeCoPro:
      {
        int cpnum = *(int *) arg1;
        struct Dbg_CoProDesc *cpd = (struct Dbg_CoProDesc *) arg2;
        int i;
        unsigned char const *map = state->CPRegWords[cpnum];
        if (map == NULL)
          return RDIError_UnknownCoPro;
        for (i = 0; i < cpd->entries; i++)
          {
            unsigned r, w = cpd->regdesc[i].nbytes / sizeof (ARMword);
            for (r = cpd->regdesc[i].rmin; r <= cpd->regdesc[i].rmax; r++)
              if (map[r] != w)
                return RDIError_BadCoProState;
          }
        return RDIError_NoError;
      }

    case RDIInfo_RequestCoProDesc:
      {
        int cpnum = *(int *) arg1;
        struct Dbg_CoProDesc *cpd = (struct Dbg_CoProDesc *) arg2;
        int i = -1, lastw = -1, r;
        unsigned char const *map;
        if ((unsigned) cpnum >= 16)
          return RDIError_UnknownCoPro;
        map = state->CPRegWords[cpnum];
        if (map == NULL)
          return RDIError_UnknownCoPro;
        for (r = 0; r < map[-1]; r++)
          {
            int words = map[r];
            if (words == lastw)
              cpd->regdesc[i].rmax = r;
            else
              {
                if (++i >= cpd->entries)
                  return RDIError_BufferFull;
                cpd->regdesc[i].rmax = cpd->regdesc[i].rmin = r;
                cpd->regdesc[i].nbytes = words * sizeof (ARMword);
                cpd->regdesc[i].access =
                  Dbg_Access_Readable + Dbg_Access_Writable;
              }
          }
        cpd->entries = i + 1;
        return RDIError_NoError;
      }

    case RDIInfo_Log:
      *arg1 = (ARMword) rdi_log;
      return RDIError_NoError;

    case RDIInfo_SetLog:
      rdi_log = (int) *arg1;
      return RDIError_NoError;

    case RDIInfo_CoPro:
      return RDIError_NoError;

    case RDIPointStatus_Watch:
      {
        WatchNode *p, *handle = (WatchNode *) * arg1;
        for (p = WatchList; p != NULL; p = p->next)
          if (p == handle)
            {
              *arg1 = -1;
              *arg2 = 1;
              return RDIError_NoError;
            }
        return RDIError_NoSuchPoint;
      }

    case RDIPointStatus_Break:
      {
        BreakNode *p, *handle = (BreakNode *) * arg1;
        for (p = BreakList; p != NULL; p = p->next)
          if (p == handle)
            {
              *arg1 = -1;
              *arg2 = 1;
              return RDIError_NoError;
            }
        return RDIError_NoSuchPoint;
      }

    case RDISet_RDILevel:
      if (*arg1 < LOWEST_RDI_LEVEL || *arg1 > HIGHEST_RDI_LEVEL)
        return RDIError_IncompatibleRDILevels;
      MYrdi_level = *arg1;
      return RDIError_NoError;

    default:
      return RDIError_UnimplementedMessage;

    }
}

/***************************************************************************\
* The emulator calls this routine at the beginning of every cycle when the  *
* CallDebug flag is set.  The second parameter passed is the address of the *
* currently executing instruction (i.e Program Counter - 8), the third      *
* parameter is the instruction being executed.                              *
\***************************************************************************/

ARMword
ARMul_Debug (ARMul_State * state, ARMword pc, ARMword instr)
{

  if (state->EndCondition == RDIError_UserInterrupt)
    {
      TracePrint ((state, "User interrupt at %.8lx\n", pc));
      state->CallDebug--;
      state->Emulate = STOP;
    }
  else
    {
      BreakNode *p = BreakList;
      for (; p != NULL; p = p->next)
        {
          switch (p->type)
            {
            case RDIPoint_EQ:
              if (pc == p->address)
                break;
              continue;
            case RDIPoint_GT:
              if (pc > p->address)
                break;
              continue;
            case RDIPoint_GE:
              if (pc >= p->address)
                break;
              continue;
            case RDIPoint_LT:
              if (pc < p->address)
                break;
              continue;
            case RDIPoint_LE:
              if (pc <= p->address)
                break;
              continue;
            case RDIPoint_IN:
              if (p->address <= pc && pc < p->address + p->bound)
                break;
              continue;
            case RDIPoint_OUT:
              if (p->address > pc || pc >= p->address + p->bound)
                break;
              continue;
            case RDIPoint_MASK:
              if ((pc & p->bound) == p->address)
                break;
              continue;
            }
          /* found a match */
          TracePrint ((state, "Breakpoint reached at %.8lx\n", pc));
          state->EndCondition = RDIError_BreakpointReached;
          state->Emulate = STOP;
          state->StopHandle = (ARMword) p;
          break;
        }
    }
  return instr;
}

void
ARMul_CheckWatch (ARMul_State * state, ARMword addr, int access)
{
  WatchNode *p;
  for (p = WatchList; p != NULL; p = p->next)
    if (p->datatype & access)
      {
        switch (p->type)
          {
          case RDIPoint_EQ:
            if (addr == p->address)
              break;
            continue;
          case RDIPoint_GT:
            if (addr > p->address)
              break;
            continue;
          case RDIPoint_GE:
            if (addr >= p->address)
              break;
            continue;
          case RDIPoint_LT:
            if (addr < p->address)
              break;
            continue;
          case RDIPoint_LE:
            if (addr <= p->address)
              break;
            continue;
          case RDIPoint_IN:
            if (p->address <= addr && addr < p->address + p->bound)
              break;
            continue;
          case RDIPoint_OUT:
            if (p->address > addr || addr >= p->address + p->bound)
              break;
            continue;
          case RDIPoint_MASK:
            if ((addr & p->bound) == p->address)
              break;
            continue;
          }
        /* found a match */
        TracePrint ((state, "Watchpoint at %.8lx accessed\n", addr));
        state->EndCondition = RDIError_WatchpointAccessed;
        state->Emulate = STOP;
        state->StopHandle = (ARMword) p;
        return;
      }
}

static RDI_NameList const *
RDI_cpunames ()
{
  return (RDI_NameList const *) &processorconfig.count;
}

const struct RDIProcVec armul_rdi = {
  "ARMUL",
  RDI_open,
  RDI_close,
  RDI_read,
  RDI_write,
  RDI_CPUread,
  RDI_CPUwrite,
  RDI_CPread,
  RDI_CPwrite,
  RDI_setbreak,
  RDI_clearbreak,
  RDI_setwatch,
  RDI_clearwatch,
  RDI_execute,
  RDI_step,
  RDI_info,

  0,                            /*pointinq */
  0,                            /*addconfig */
  0,                            /*loadconfigdata */
  0,                            /*selectconfig */
  0,                            /*drivernames */

  RDI_cpunames
};