PARAMS removal.

[thirdparty/binutils-gdb.git] / gdb / remote-rdi.c

/* GDB interface to ARM RDI library.
   Copyright 1997, 1998 Free Software Foundation, Inc.

   This file is part of GDB.

   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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "gdb_string.h"
#include <fcntl.h>
#include "frame.h"
#include "inferior.h"
#include "bfd.h"
#include "symfile.h"
#include "target.h"
#include "gdb_wait.h"
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdb-stabs.h"
#include "gdbthread.h"
#include "gdbcore.h"
#include "breakpoint.h"

#ifdef USG
#include <sys/types.h>
#endif

#include <signal.h>

#include "rdi-share/ardi.h"
#include "rdi-share/adp.h"
#include "rdi-share/hsys.h"

extern int isascii (int);

/* Prototypes for local functions */

static void arm_rdi_files_info (struct target_ops *ignore);

static int arm_rdi_xfer_memory (CORE_ADDR memaddr, char *myaddr,
				int len, int should_write,
				struct target_ops *target);

static void arm_rdi_prepare_to_store (void);

static void arm_rdi_fetch_registers (int regno);

static void arm_rdi_resume (int pid, int step, enum target_signal siggnal);

static int arm_rdi_start_remote (char *dummy);

static void arm_rdi_open (char *name, int from_tty);

static void arm_rdi_create_inferior (char *exec_file, char *args, char **env);

static void arm_rdi_close (int quitting);

static void arm_rdi_store_registers (int regno);

static void arm_rdi_mourn (void);

static void arm_rdi_send (char *buf);

static int arm_rdi_wait (int pid, struct target_waitstatus *status);

static void arm_rdi_kill (void);

static void arm_rdi_detach (char *args, int from_tty);

static void arm_rdi_interrupt (int signo);

static void arm_rdi_interrupt_twice (int signo);

static void interrupt_query (void);

static int arm_rdi_insert_breakpoint (CORE_ADDR, char *);

static int arm_rdi_remove_breakpoint (CORE_ADDR, char *);

static char *rdi_error_message (int err);

static enum target_signal rdi_error_signal (int err);

/* Global variables.  */

struct target_ops arm_rdi_ops;

static struct Dbg_ConfigBlock gdb_config;

static struct Dbg_HostosInterface gdb_hostif;

static int max_load_size;

static int execute_status;

/* Send heatbeat packets? */
static int rdi_heartbeat = 0;

/* Target has ROM at address 0. */
static int rom_at_zero = 0;

/* Enable logging? */
static int log_enable = 0;

/* Name of the log file. Default is "rdi.log". */
static char *log_filename;

/* A little list of breakpoints that have been set.  */

static struct local_bp_list_entry
  {
    CORE_ADDR addr;
    PointHandle point;
    struct local_bp_list_entry *next;
  }
 *local_bp_list;
\f

/* Stub for catch_errors.  */

static int
arm_rdi_start_remote (dummy)
     char *dummy;
{
  return 1;
}

/* Helper callbacks for the "host interface" structure.  RDI functions call
   these to forward output from the target system and so forth.  */

void
voiddummy ()
{
  fprintf_unfiltered (gdb_stdout, "void dummy\n");
}

static void
myprint (arg, format, ap)
     PTR arg;
     const char *format;
     va_list ap;
{
  vfprintf_unfiltered (gdb_stdout, format, ap);
}

static void
mywritec (arg, c)
     PTR arg;
     int c;
{
  if (isascii (c))
    fputc_unfiltered (c, gdb_stdout);
}

static int
mywrite (arg, buffer, len)
     PTR arg;
     char const *buffer;
     int len;
{
  int i;
  char *e;

  e = (char *) buffer;
  for (i = 0; i < len; i++)
    {
      if (isascii ((int) *e))
	{
	  fputc_unfiltered ((int) *e, gdb_stdout);
	  e++;
	}
    }

  return len;
}

static void
mypause (arg)
     PTR arg;
{
}

/* These last two are tricky as we have to handle the special case of
   being interrupted more carefully */

static int
myreadc (arg)
     PTR arg;
{
  return fgetc (stdin);
}

static char *
mygets (arg, buffer, len)
     PTR arg;
     char *buffer;
     int len;
{
  return fgets (buffer, len, stdin);
}

/* Prevent multiple calls to angel_RDI_close().  */
static int closed_already = 1;

/* Open a connection to a remote debugger.  NAME is the filename used
   for communication.  */

static void
arm_rdi_open (name, from_tty)
     char *name;
     int from_tty;
{
  int rslt, i;
  unsigned long arg1, arg2;
  char *openArgs = NULL;
  char *devName = NULL;
  char *p;

  if (name == NULL)
    error ("To open an RDI connection, you need to specify what serial\n\
device is attached to the remote system (e.g. /dev/ttya).");

  /* split name after whitespace, pass tail as arg to open command */

  devName = xstrdup (name);
  p = strchr (devName, ' ');
  if (p)
    {
      *p = '\0';
      ++p;

      while (*p == ' ')
	++p;

      openArgs = p;
    }

  /* Make the basic low-level connection.  */

  arm_rdi_close (0);
  rslt = Adp_OpenDevice (devName, openArgs, rdi_heartbeat);

  if (rslt != adp_ok)
    error ("Could not open device \"%s\"", name);

  gdb_config.bytesex = 2 | (TARGET_BYTE_ORDER == BIG_ENDIAN ? 1 : 0);
  gdb_config.fpe = 1;
  gdb_config.rditype = 2;
  gdb_config.heartbeat_on = 1;
  gdb_config.flags = 2;

  gdb_hostif.dbgprint = myprint;
  gdb_hostif.dbgpause = mypause;
  gdb_hostif.dbgarg = NULL;
  gdb_hostif.writec = mywritec;
  gdb_hostif.readc = myreadc;
  gdb_hostif.write = mywrite;
  gdb_hostif.gets = mygets;
  gdb_hostif.hostosarg = NULL;
  gdb_hostif.reset = voiddummy;

  rslt = angel_RDI_open (10, &gdb_config, &gdb_hostif, NULL);
  if (rslt == RDIError_BigEndian || rslt == RDIError_LittleEndian)
    ;				/* do nothing, this is the expected return */
  else if (rslt)
    {
      printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
      Adp_CloseDevice ();
      error ("RID_open failed\n");
    }

  rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  rslt = angel_RDI_info (RDIInfo_Points, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  rslt = angel_RDI_info (RDIInfo_CoPro, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  rslt = angel_RDI_info (RDIInfo_SemiHosting, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }

  rslt = angel_RDI_info (RDIInfo_GetLoadSize, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  max_load_size = arg1;

  push_target (&arm_rdi_ops);

  target_fetch_registers (-1);

  rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
  if (rslt)
    {
      printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
    }

  arg1 = rom_at_zero ? 0x0 : 0x13b;

  rslt = angel_RDI_info (RDIVector_Catch, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }

  arg1 = (unsigned long) "";
  rslt = angel_RDI_info (RDISet_Cmdline, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }

  /* Clear out any existing records of breakpoints.  */
  {
    struct local_bp_list_entry *entry, *preventry = NULL;

    for (entry = local_bp_list; entry != NULL; entry = entry->next)
      {
	if (preventry)
	  free (preventry);
      }
  }

  printf_filtered ("Connected to ARM RDI target.\n");
  closed_already = 0;
  inferior_pid = 42;
}

/* Start an inferior process and set inferior_pid to its pid.
   EXEC_FILE is the file to run.
   ARGS is a string containing the arguments to the program.
   ENV is the environment vector to pass.  Errors reported with error().
   On VxWorks and various standalone systems, we ignore exec_file.  */
/* This is called not only when we first attach, but also when the
   user types "run" after having attached.  */

static void
arm_rdi_create_inferior (exec_file, args, env)
     char *exec_file;
     char *args;
     char **env;
{
  int len, rslt;
  unsigned long arg1, arg2;
  char *arg_buf;
  CORE_ADDR entry_point;

  if (exec_file == 0 || exec_bfd == 0)
    error ("No executable file specified.");

  entry_point = (CORE_ADDR) bfd_get_start_address (exec_bfd);

  arm_rdi_kill ();
  remove_breakpoints ();
  init_wait_for_inferior ();

  len = strlen (exec_file) + 1 + strlen (args) + 1 + /*slop */ 10;
  arg_buf = (char *) alloca (len);
  arg_buf[0] = '\0';
  strcat (arg_buf, exec_file);
  strcat (arg_buf, " ");
  strcat (arg_buf, args);

  inferior_pid = 42;
  insert_breakpoints ();	/* Needed to get correct instruction in cache */

  if (env != NULL)
    {
      while (*env)
	{
	  if (strncmp (*env, "MEMSIZE=", sizeof ("MEMSIZE=") - 1) == 0)
	    {
	      unsigned long top_of_memory;
	      char *end_of_num;

	      /* Set up memory limit */
	      top_of_memory = strtoul (*env + sizeof ("MEMSIZE=") - 1,
				       &end_of_num, 0);
	      printf_filtered ("Setting top-of-memory to 0x%lx\n",
			       top_of_memory);

	      rslt = angel_RDI_info (RDIInfo_SetTopMem, &top_of_memory, &arg2);
	      if (rslt)
		{
		  printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
		}
	    }
	  env++;
	}
    }

  arg1 = (unsigned long) arg_buf;
  rslt = angel_RDI_info (RDISet_Cmdline, /* &arg1 */ (unsigned long *) arg_buf, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }

  proceed (entry_point, TARGET_SIGNAL_DEFAULT, 0);
}

/* This takes a program previously attached to and detaches it.  After
   this is done, GDB can be used to debug some other program.  We
   better not have left any breakpoints in the target program or it'll
   die when it hits one.  */

static void
arm_rdi_detach (args, from_tty)
     char *args;
     int from_tty;
{
  pop_target ();
}

/* Clean up connection to a remote debugger.  */

static void
arm_rdi_close (quitting)
     int quitting;
{
  int rslt;

  if (!closed_already)
    {
      rslt = angel_RDI_close ();
      if (rslt)
	{
	  printf_filtered ("RDI_close: %s\n", rdi_error_message (rslt));
	}
      closed_already = 1;
      inferior_pid = 0;
      Adp_CloseDevice ();
      generic_mourn_inferior ();
    }
}
\f
/* Tell the remote machine to resume.  */

static void
arm_rdi_resume (pid, step, siggnal)
     int pid, step;
     enum target_signal siggnal;
{
  int rslt;
  PointHandle point;

  if (0 /* turn on when hardware supports single-stepping */ )
    {
      rslt = angel_RDI_step (1, &point);
      if (rslt)
	{
	  printf_filtered ("RDI_step: %s\n", rdi_error_message (rslt));
	}
    }
  else
    {
      char handle[4];
      CORE_ADDR pc;

      if (step)
	{
	  pc = read_register (PC_REGNUM);
	  pc = arm_get_next_pc (pc);
	  arm_rdi_insert_breakpoint (pc, handle);
	}
      execute_status = rslt = angel_RDI_execute (&point);
      if (rslt == RDIError_BreakpointReached)
	;
      else if (rslt)
	{
	  printf_filtered ("RDI_execute: %s\n", rdi_error_message (rslt));
	}
      if (step)
	{
	  arm_rdi_remove_breakpoint (pc, handle);
	}
    }
}
\f
/* Send ^C to target to halt it.  Target will respond, and send us a
   packet.  */

static void
arm_rdi_interrupt (signo)
     int signo;
{
}

static void (*ofunc) ();

/* The user typed ^C twice.  */
static void
arm_rdi_interrupt_twice (signo)
     int signo;
{
}

/* Ask the user what to do when an interrupt is received.  */

static void
interrupt_query ()
{
}

/* Wait until the remote machine stops, then return, storing status in
   STATUS just as `wait' would.  Returns "pid" (though it's not clear
   what, if anything, that means in the case of this target).  */

static int
arm_rdi_wait (pid, status)
     int pid;
     struct target_waitstatus *status;
{
  status->kind = (execute_status == RDIError_NoError ?
		  TARGET_WAITKIND_EXITED : TARGET_WAITKIND_STOPPED);

  /* convert stopped code from target into right signal */
  status->value.sig = rdi_error_signal (execute_status);

  return inferior_pid;
}

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

/* ARGSUSED */
static void
arm_rdi_fetch_registers (regno)
     int regno;
{
  int rslt, rdi_regmask;
  unsigned long rawreg, rawregs[32];
  char cookedreg[4];

  if (regno == -1)
    {
      rslt = angel_RDI_CPUread (255, 0x27fff, rawregs);
      if (rslt)
	{
	  printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
	}

      for (regno = 0; regno < 15; regno++)
	{
	  store_unsigned_integer (cookedreg, 4, rawregs[regno]);
	  supply_register (regno, (char *) cookedreg);
	}
      store_unsigned_integer (cookedreg, 4, rawregs[15]);
      supply_register (PS_REGNUM, (char *) cookedreg);
      arm_rdi_fetch_registers (PC_REGNUM);
    }
  else
    {
      if (regno == PC_REGNUM)
	rdi_regmask = RDIReg_PC;
      else if (regno == PS_REGNUM)
	rdi_regmask = RDIReg_CPSR;
      else if (regno < 0 || regno > 15)
	{
	  rawreg = 0;
	  supply_register (regno, (char *) &rawreg);
	  return;
	}
      else
	rdi_regmask = 1 << regno;

      rslt = angel_RDI_CPUread (255, rdi_regmask, &rawreg);
      if (rslt)
	{
	  printf_filtered ("RDI_CPUread: %s\n", rdi_error_message (rslt));
	}
      store_unsigned_integer (cookedreg, 4, rawreg);
      supply_register (regno, (char *) cookedreg);
    }
}

static void
arm_rdi_prepare_to_store ()
{
  /* Nothing to do.  */
}

/* Store register REGNO, or all registers if REGNO == -1, from the contents
   of REGISTERS.  FIXME: ignores errors.  */

static void
arm_rdi_store_registers (regno)
     int regno;
{
  int rslt, rdi_regmask;

  /* These need to be able to take 'floating point register' contents */
  unsigned long rawreg[3], rawerreg[3];

  if (regno == -1)
    {
      for (regno = 0; regno < NUM_REGS; regno++)
	arm_rdi_store_registers (regno);
    }
  else
    {
      read_register_gen (regno, (char *) rawreg);
      /* RDI manipulates data in host byte order, so convert now. */
      store_unsigned_integer (rawerreg, 4, rawreg[0]);

      if (regno == PC_REGNUM)
	rdi_regmask = RDIReg_PC;
      else if (regno == PS_REGNUM)
	rdi_regmask = RDIReg_CPSR;
      else if (regno < 0 || regno > 15)
	return;
      else
	rdi_regmask = 1 << regno;

      rslt = angel_RDI_CPUwrite (255, rdi_regmask, rawerreg);
      if (rslt)
	{
	  printf_filtered ("RDI_CPUwrite: %s\n", rdi_error_message (rslt));
	}
    }
}
\f
/* Read or write LEN bytes from inferior memory at MEMADDR,
   transferring to or from debugger address MYADDR.  Write to inferior
   if SHOULD_WRITE is nonzero.  Returns length of data written or
   read; 0 for error.  */

/* ARGSUSED */
static int
arm_rdi_xfer_memory (memaddr, myaddr, len, should_write, target)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
     int should_write;
     struct target_ops *target;	/* ignored */
{
  int rslt, i;

  if (should_write)
    {
      rslt = angel_RDI_write (myaddr, memaddr, &len);
      if (rslt)
	{
	  printf_filtered ("RDI_write: %s\n", rdi_error_message (rslt));
	}
    }
  else
    {
      rslt = angel_RDI_read (memaddr, myaddr, &len);
      if (rslt)
	{
	  printf_filtered ("RDI_read: %s\n", rdi_error_message (rslt));
	  len = 0;
	}
    }
  return len;
}
\f
/* Display random info collected from the target.  */

static void
arm_rdi_files_info (ignore)
     struct target_ops *ignore;
{
  char *file = "nothing";
  int rslt;
  unsigned long arg1, arg2;

  rslt = angel_RDI_info (RDIInfo_Target, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  if (arg1 & (1 << 15))
    printf_filtered ("Target supports Thumb code.\n");
  if (arg1 & (1 << 14))
    printf_filtered ("Target can do profiling.\n");
  if (arg1 & (1 << 4))
    printf_filtered ("Target is real hardware.\n");

  rslt = angel_RDI_info (RDIInfo_Step, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  printf_filtered ("Target can%s single-step.\n", (arg1 & 0x4 ? "" : "not"));

  rslt = angel_RDI_info (RDIInfo_Icebreaker, &arg1, &arg2);
  if (rslt)
    {
      printf_filtered ("RDI_info: %s\n", rdi_error_message (rslt));
    }
  else
    printf_filtered ("Target includes an EmbeddedICE.\n");
}
\f
static void
arm_rdi_kill ()
{
  int rslt;

  rslt = angel_RDI_open (1, &gdb_config, NULL, NULL);
  if (rslt)
    {
      printf_filtered ("RDI_open: %s\n", rdi_error_message (rslt));
    }
}

static void
arm_rdi_mourn_inferior ()
{
  /* We remove the inserted breakpoints in case the user wants to
     issue another target and load commands to rerun his application;
     This is something that wouldn't work on a native target, for instance,
     as the process goes away when the inferior exits, but it works with
     some remote targets like this one.  That is why this is done here. */
  remove_breakpoints();
  unpush_target (&arm_rdi_ops);
  generic_mourn_inferior ();
}
\f
/* While the RDI library keeps track of its own breakpoints, we need
   to remember "handles" so that we can delete them later.  Since
   breakpoints get used for stepping, be careful not to leak memory
   here.  */

static int
arm_rdi_insert_breakpoint (addr, contents_cache)
     CORE_ADDR addr;
     char *contents_cache;
{
  int rslt;
  PointHandle point;
  struct local_bp_list_entry *entry;
  int type = RDIPoint_EQ;

  if (arm_pc_is_thumb (addr) || arm_pc_is_thumb_dummy (addr))
    type |= RDIPoint_16Bit;
  rslt = angel_RDI_setbreak (addr, type, 0, &point);
  if (rslt)
    {
      printf_filtered ("RDI_setbreak: %s\n", rdi_error_message (rslt));
    }
  entry =
    (struct local_bp_list_entry *) xmalloc (sizeof (struct local_bp_list_entry));
  entry->addr = addr;
  entry->point = point;
  entry->next = local_bp_list;
  local_bp_list = entry;
  return rslt;
}

static int
arm_rdi_remove_breakpoint (addr, contents_cache)
     CORE_ADDR addr;
     char *contents_cache;
{
  int rslt;
  PointHandle point;
  struct local_bp_list_entry *entry, *preventry;

  for (entry = local_bp_list; entry != NULL; entry = entry->next)
    {
      if (entry->addr == addr)
	{
	  break;
	}
      preventry = entry;
    }
  if (entry)
    {
      rslt = angel_RDI_clearbreak (entry->point);
      if (rslt)
	{
	  printf_filtered ("RDI_clearbreak: %s\n", rdi_error_message (rslt));
	}
      /* Delete the breakpoint entry locally.  */
      if (entry == local_bp_list)
	{
	  local_bp_list = entry->next;
	}
      else
	{
	  preventry->next = entry->next;
	}
      free (entry);
    }
  return 0;
}
\f
static char *
rdi_error_message (err)
     int err;
{
  switch (err)
    {
    case RDIError_NoError:
      return "no error";
    case RDIError_Reset:
      return "debuggee reset";
    case RDIError_UndefinedInstruction:
      return "undefined instruction";
    case RDIError_SoftwareInterrupt:
      return "SWI trapped";
    case RDIError_PrefetchAbort:
      return "prefetch abort, execution ran into unmapped memory?";
    case RDIError_DataAbort:
      return "data abort, no memory at specified address?";
    case RDIError_AddressException:
      return "address exception, access >26bit in 26bit mode";
    case RDIError_IRQ:
      return "IRQ, interrupt trapped";
    case RDIError_FIQ:
      return "FIQ, fast interrupt trapped";
    case RDIError_Error:
      return "a miscellaneous type of error";
    case RDIError_BranchThrough0:
      return "branch through location 0";
    case RDIError_NotInitialised:
      return "internal error, RDI_open not called first";
    case RDIError_UnableToInitialise:
      return "internal error, target world is broken";
    case RDIError_WrongByteSex:
      return "See Operator: WrongByteSex";
    case RDIError_UnableToTerminate:
      return "See Operator: Unable to Terminate";
    case RDIError_BadInstruction:
      return "bad instruction, illegal to execute this instruction";
    case RDIError_IllegalInstruction:
      return "illegal instruction, the effect of executing it is undefined";
    case RDIError_BadCPUStateSetting:
      return "internal error, tried to set SPSR of user mode";
    case RDIError_UnknownCoPro:
      return "unknown co-processor";
    case RDIError_UnknownCoProState:
      return "cannot execute co-processor request";
    case RDIError_BadCoProState:
      return "recognizably broken co-processor request";
    case RDIError_BadPointType:
      return "internal error, bad point yype";
    case RDIError_UnimplementedType:
      return "internal error, unimplemented type";
    case RDIError_BadPointSize:
      return "internal error, bad point size";
    case RDIError_UnimplementedSize:
      return "internal error, unimplemented size";
    case RDIError_NoMorePoints:
      return "last break/watch point was used";
    case RDIError_BreakpointReached:
      return "breakpoint reached";
    case RDIError_WatchpointAccessed:
      return "watchpoint accessed";
    case RDIError_NoSuchPoint:
      return "attempted to clear non-existent break/watch point";
    case RDIError_ProgramFinishedInStep:
      return "end of the program reached while stepping";
    case RDIError_UserInterrupt:
      return "you pressed Escape";
    case RDIError_CantSetPoint:
      return "no more break/watch points available";
    case RDIError_IncompatibleRDILevels:
      return "incompatible RDI levels";
    case RDIError_LittleEndian:
      return "debuggee is little endian";
    case RDIError_BigEndian:
      return "debuggee is big endian";
    case RDIError_SoftInitialiseError:
      return "recoverable error in RDI initialization";
    case RDIError_InsufficientPrivilege:
      return "internal error, supervisor state not accessible to monitor";
    case RDIError_UnimplementedMessage:
      return "internal error, unimplemented message";
    case RDIError_UndefinedMessage:
      return "internal error, undefined message";
    default:
      return "undefined error message, should reset target";
    }
}

/* Convert the ARM error messages to signals that GDB knows about.  */

static enum target_signal
rdi_error_signal (err)
     int err;
{
  switch (err)
    {
    case RDIError_NoError:
      return 0;
    case RDIError_Reset:
      return TARGET_SIGNAL_TERM;	/* ??? */
    case RDIError_UndefinedInstruction:
      return TARGET_SIGNAL_ILL;
    case RDIError_SoftwareInterrupt:
    case RDIError_PrefetchAbort:
    case RDIError_DataAbort:
      return TARGET_SIGNAL_TRAP;
    case RDIError_AddressException:
      return TARGET_SIGNAL_SEGV;
    case RDIError_IRQ:
    case RDIError_FIQ:
      return TARGET_SIGNAL_TRAP;
    case RDIError_Error:
      return TARGET_SIGNAL_TERM;
    case RDIError_BranchThrough0:
      return TARGET_SIGNAL_TRAP;
    case RDIError_NotInitialised:
    case RDIError_UnableToInitialise:
    case RDIError_WrongByteSex:
    case RDIError_UnableToTerminate:
      return TARGET_SIGNAL_UNKNOWN;
    case RDIError_BadInstruction:
    case RDIError_IllegalInstruction:
      return TARGET_SIGNAL_ILL;
    case RDIError_BadCPUStateSetting:
    case RDIError_UnknownCoPro:
    case RDIError_UnknownCoProState:
    case RDIError_BadCoProState:
    case RDIError_BadPointType:
    case RDIError_UnimplementedType:
    case RDIError_BadPointSize:
    case RDIError_UnimplementedSize:
    case RDIError_NoMorePoints:
      return TARGET_SIGNAL_UNKNOWN;
    case RDIError_BreakpointReached:
    case RDIError_WatchpointAccessed:
      return TARGET_SIGNAL_TRAP;
    case RDIError_NoSuchPoint:
    case RDIError_ProgramFinishedInStep:
      return TARGET_SIGNAL_UNKNOWN;
    case RDIError_UserInterrupt:
      return TARGET_SIGNAL_INT;
    case RDIError_IncompatibleRDILevels:
    case RDIError_LittleEndian:
    case RDIError_BigEndian:
    case RDIError_SoftInitialiseError:
    case RDIError_InsufficientPrivilege:
    case RDIError_UnimplementedMessage:
    case RDIError_UndefinedMessage:
    default:
      return TARGET_SIGNAL_UNKNOWN;
    }
}
\f
/* Define the target operations structure.  */

static void
init_rdi_ops ()
{
  arm_rdi_ops.to_shortname = "rdi";
  arm_rdi_ops.to_longname = "ARM RDI";
  arm_rdi_ops.to_doc = "Use a remote ARM-based computer; via the RDI library.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  arm_rdi_ops.to_open = arm_rdi_open;
  arm_rdi_ops.to_close = arm_rdi_close;
  arm_rdi_ops.to_detach = arm_rdi_detach;
  arm_rdi_ops.to_resume = arm_rdi_resume;
  arm_rdi_ops.to_wait = arm_rdi_wait;
  arm_rdi_ops.to_fetch_registers = arm_rdi_fetch_registers;
  arm_rdi_ops.to_store_registers = arm_rdi_store_registers;
  arm_rdi_ops.to_prepare_to_store = arm_rdi_prepare_to_store;
  arm_rdi_ops.to_xfer_memory = arm_rdi_xfer_memory;
  arm_rdi_ops.to_files_info = arm_rdi_files_info;
  arm_rdi_ops.to_insert_breakpoint = arm_rdi_insert_breakpoint;
  arm_rdi_ops.to_remove_breakpoint = arm_rdi_remove_breakpoint;
  arm_rdi_ops.to_kill = arm_rdi_kill;
  arm_rdi_ops.to_load = generic_load;
  arm_rdi_ops.to_create_inferior = arm_rdi_create_inferior;
  arm_rdi_ops.to_mourn_inferior = arm_rdi_mourn_inferior;
  arm_rdi_ops.to_stratum = process_stratum;
  arm_rdi_ops.to_has_all_memory = 1;
  arm_rdi_ops.to_has_memory = 1;
  arm_rdi_ops.to_has_stack = 1;
  arm_rdi_ops.to_has_registers = 1;
  arm_rdi_ops.to_has_execution = 1;
  arm_rdi_ops.to_magic = OPS_MAGIC;
}

static void 
rdilogfile_command (char *arg, int from_tty)
{
  if (!arg || strlen (arg) == 0)
    {
      printf_filtered ("rdi log file is '%s'\n", log_filename);
      return;
    }

  if (log_filename)
    free (log_filename);

  log_filename = xstrdup (arg);

  Adp_SetLogfile (log_filename);
}

static void 
rdilogenable_command (char *args, int from_tty)
{
  if (!args || strlen (args) == 0)
    {
      printf_filtered ("rdi log is %s\n", log_enable ? "enabled" : "disabled");
      return;
    }

  if (!strcasecmp (args, "1") ||
      !strcasecmp (args, "y") ||
      !strcasecmp (args, "yes") ||
      !strcasecmp (args, "on") ||
      !strcasecmp (args, "t") ||
      !strcasecmp (args, "true"))
    Adp_SetLogEnable (log_enable = 1);
  else if (!strcasecmp (args, "0") ||
	   !strcasecmp (args, "n") ||
	   !strcasecmp (args, "no") ||
	   !strcasecmp (args, "off") ||
	   !strcasecmp (args, "f") ||
	   !strcasecmp (args, "false"))
    Adp_SetLogEnable (log_enable = 0);
  else
    printf_filtered ("rdilogenable: unrecognized argument '%s'\n"
		     "              try y or n\n", args);
}

void
_initialize_remote_rdi ()
{
  init_rdi_ops ();
  add_target (&arm_rdi_ops);

  log_filename = xstrdup ("rdi.log");
  Adp_SetLogfile (log_filename);
  Adp_SetLogEnable (log_enable);

  add_cmd ("rdilogfile", class_maintenance,
	   rdilogfile_command,
	   "Set filename for ADP packet log.\n\
This file is used to log Angel Debugger Protocol packets.\n\
With a single argument, sets the logfile name to that value.\n\
Without an argument, shows the current logfile name.\n\
See also: rdilogenable\n",
	   &maintenancelist);

  add_cmd ("rdilogenable", class_maintenance,
	   rdilogenable_command,
	   "Set enable logging of ADP packets.\n\
This will log ADP packets exchanged between gdb and the\n\
rdi target device.\n\
An argument of 1,t,true,y,yes will enable.\n\
An argument of 0,f,false,n,no will disabled.\n\
Withough an argument, it will display current state.\n",
	   &maintenancelist);

  add_show_from_set
    (add_set_cmd ("rdiromatzero", no_class,
		  var_boolean, (char *) &rom_at_zero,
		  "Set target has ROM at addr 0.\n\
A true value disables vector catching, false enables vector catching.\n\
This is evaluated at the time the 'target rdi' command is executed\n",
		  &setlist),
     &showlist);

  add_show_from_set
    (add_set_cmd ("rdiheartbeat", no_class,
		  var_boolean, (char *) &rdi_heartbeat,
		  "Set enable for ADP heartbeat packets.\n\
I don't know why you would want this. If you enable them,\n\
it will confuse ARM and EPI JTAG interface boxes as well\n\
as the Angel Monitor.\n",
		  &setlist),
     &showlist);
}

/* A little dummy to make linking with the library succeed. */

int
Fail ()
{
  return 0;
}