[binutils.git] / gdb / v850ice.c

/* ICE interface for the NEC V850 for GDB, the GNU debugger.
   Copyright 1996, 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"
#if 0
#include "frame.h"
#endif
#include "inferior.h"
#if 0
#include "bfd.h"
#endif
#include "symfile.h"
#include "target.h"
#if 0
#include "wait.h"
#include "gdbcmd.h"
#include "objfiles.h"
#include "gdb-stabs.h"
#include "gdbthread.h"
#endif
#define WIN32_LEAN_AND_MEAN
#include <windows.h> 

/* Prototypes for local functions */

static void v850ice_files_info PARAMS ((struct target_ops *ignore));

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

static void v850ice_prepare_to_store PARAMS ((void));

static void v850ice_fetch_registers PARAMS ((int regno));

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

static void v850ice_open PARAMS ((char *name, int from_tty));

static void v850ice_close PARAMS ((int quitting));

static void v850ice_store_registers PARAMS ((int regno));

static void v850ice_mourn PARAMS ((void));

static int v850ice_wait PARAMS ((int pid, struct target_waitstatus *status));

static void v850ice_kill PARAMS ((void));

static void v850ice_detach PARAMS ((char *args, int from_tty));

static int v850ice_insert_breakpoint PARAMS ((CORE_ADDR, char *));

static int v850ice_remove_breakpoint PARAMS ((CORE_ADDR, char *));

static int ice_open = 0;

static struct target_ops v850ice_ops ;	

#ifndef EXPORT
#define EXPORT __declspec(dllexport)
#endif

struct MessageIO
{
  int size;			/* length of input or output in bytes */
  char *buf;			/* buffer having the input/output information */
};

struct MessageIO null_iob = { 0, NULL };

EXPORT long __stdcall ExeAppReq (char *, long, char *, struct MessageIO *);
EXPORT long __stdcall RegisterClient (HWND);
EXPORT long __stdcall UnregisterClient (void);
EXPORT long __stdcall GdbCallBack (void);

#define	MREADREG          0x0001
#define	MWRITEREG         0x0002
#define	MREADMEM          0x0003
#define	MWRITEMEM         0x0004
#define	MSINGLESTEP       0x0005
#define	MRESUME           0x0006
#define	MLOADPROGRAM      0x0007
#define	MSETBREAK         0x0008
#define	MREMOVEBREAK      0x0009
#define	MQUIT             0x000A
#define	MTERMINATE        0x000B
#define	MATTACH           0x000C
#define	MCHECKSTATUS      0x000D
#define	MHALT             0x000E
#define	MDIRECTCMD        0x000F
#define	MSYMADR           0x0010
#define	MGETTASKLIST      0x0011
#define	MREADVECREG       0x0012
#define	MWRITEVECREG      0x0013
#define	MGETCHANGEDREGS   0x0014
#define	MGETSERVERINFO    0x0015
#define	MREADBLOCK        0x0016
#define	MSETHARDBRK       0x0017
#define	MREMOVEHARDBRK    0x0018
#define	MCOPYBLOCK        0x0019
#define	MBLOCKFILL        0x001A
#define	MFINDBLOCK        0x001B
#define	MCOMPAREBLOCK     0x001C
#define	MREFRESH          0x001D
#define	MSPECIAL          0x001E
#define	MGETCMDLIST       0x001F
#define	MEXPVAL           0x0020
#define	MEXPFAILED        0x0021
#define	MSAVESTATE        0x0022
#define	MWRITEBLOCK       0x0023
#define	MDETACH           0x0024
#define	MGETMODULES       0x0025
#define	MREMOTESYMBOL     0x0026
#define	MREADCSTRING      0x0027
#define	MLOADMODULE       0x0028
#define	MDIDSYSCALL       0x0029
#define	MDBPWRITEBUFFERS  0x002A
#define	MBPID		  0x002B
#define MINITEXEC         0x002C
#define	MEXITEXEC	  0x002D
#define	MRCCMD    	  0x002E
#define	MDOWNLOAD	  0x0050

#define StatRunning	0
#define StatExecBreak	1   /* an execution breakpoint has been reached */
#define StatStepped	2   /* a single step has been completed */
#define StatException	3   /* the target has stopped due to an exception */
#define StatHalted	4   /* target has been halted by a user request */
#define StatExited      5   /* target called exit */
#define StatTerminated  6   /* target program terminated by a user request */
#define StatNoProcess   7   /* no process on target and none of the above */
#define StatNeedInput   8   /* REV: obsolete */
#define StatNeedDirCmd  9   /* waiting for an entry in the remote window */
#define StatHardBreak	10  /* hit hardware breakpoint */
#define StatFailure	11  /* an error occured in the last run/single */


/*   "pir", "tkcw", "chcw", "adtre" */

/* Code for opening a connection to the ICE.  */

static void
v850ice_open (name, from_tty)
     char *name;
     int from_tty;
{
  long retval;

  if (name)
    error ("Too many arguments.");

  target_preopen (from_tty);

  unpush_target (&v850ice_ops);

  if (from_tty)
    puts_filtered ("V850ice debugging\n");

  push_target (&v850ice_ops);	/* Switch to using v850ice target now */

  target_terminal_init ();

  /* Without this, some commands which require an active target (such as kill)
     won't work.  This variable serves (at least) double duty as both the pid
     of the target process (if it has such), and as a flag indicating that a
     target is active.  These functions should be split out into seperate
     variables, especially since GDB will someday have a notion of debugging
     several processes.  */

  inferior_pid = 42000;

  /* Start the v850ice connection; if error (0), discard this target.
     In particular, if the user quits, be sure to discard it
     (we'd be in an inconsistent state otherwise).  */

  WinExec ("necsrv", SW_SHOW);	/* Start up necsrv */

  retval = RegisterClient (NULL);

  if (retval == 0)
    {
      ice_open = 1;

      start_remote ();
      return;
    }

  pop_target();

  error ("v850ice_open: MINITEXEC return error: 0x%x", retval);
}

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

/* ARGSUSED */
static void
v850ice_close (quitting)
     int quitting;
{
  long retval;

  if (ice_open)
    {
#if 0
      retval = ExeAppReq ("GDB", MEXITEXEC, NULL, &null_iob);
      if (retval)
	error ("ExeAppReq (MEXITEXEC) returned %d", retval);
#endif
      ice_open = 0;
      UnregisterClient ();
    }
}

static void
v850ice_detach (args, from_tty)
     char *args;
     int from_tty;
{
  if (args)
    error ("Argument given to \"detach\" when remotely debugging.");

  pop_target ();
  if (from_tty)
    puts_filtered ("Ending v850ice debugging.\n");
}

/* Tell the remote machine to resume.  */

static void
v850ice_resume (pid, step, siggnal)
     int pid, step;
     enum target_signal siggnal;
{
  long retval;

  if (step)
    retval = ExeAppReq ("GDB", MSINGLESTEP, "step", &null_iob);
  else
    retval = ExeAppReq ("GDB", MRESUME, "run", &null_iob);

  if (retval)
    error ("ExeAppReq (step = %d) returned %d", step, retval);
}

/* 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
v850ice_wait (pid, status)
     int pid;
     struct target_waitstatus *status;
{
  long v850_status;

  v850_status = ExeAppReq ("GDB", MCHECKSTATUS, NULL, &null_iob);

  status->kind = TARGET_WAITKIND_STOPPED;
  status->value.sig = TARGET_SIGNAL_TRAP;

  return inferior_pid;
}

static int
convert_register (regno, buf)
     int regno;
     char *buf;
{
  if (regno <= 31)
    sprintf (buf, "r%d", regno);
  else if (reg_names[regno][0] == 's'
	   && reg_names[regno][1] == 'r')
    return 0;
  else
    sprintf (buf, "%s", reg_names[regno]);

  return 1;
}

/* Read the remote registers into the block REGS.  */
/* Note that the ICE returns register contents as ascii hex strings.  We have
   to convert that to an unsigned long, and then call store_unsigned_integer to
   convert it to target byte-order if necessary.  */

static void
v850ice_fetch_registers (regno)
     int regno;
{
  long retval;
  char cmd[100];
  char val[100];
  struct MessageIO iob;
  unsigned long regval;
  char *p;

  if (regno == -1)
    {
      for (regno = 0; regno < NUM_REGS; regno++)
	v850ice_fetch_registers (regno);
      return;
    }

  strcpy (cmd, "reg ");
  if (!convert_register (regno, &cmd[4]))
    return;

  iob.size = sizeof val;
  iob.buf = val;
  retval = ExeAppReq ("GDB", MREADREG, cmd, &iob);
  if (retval)
    error ("ExeAppReq returned %d: cmd = %s", retval, cmd);

  regval = strtoul (val, &p, 16);
  if (regval == 0 && p == val)
    error ("v850ice_fetch_registers (%d):  bad value from ICE: %s.",
	   regno, val);

  store_unsigned_integer (val, REGISTER_RAW_SIZE (regno), regval);
  supply_register (regno, val);
}

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

static void
v850ice_store_registers (regno)
     int regno;
{
  long retval;
  char cmd[100];
  unsigned long regval;

  if (regno == -1)
    {
      for (regno = 0; regno < NUM_REGS; regno++)
	v850ice_store_registers (regno);
      return;
    }

  regval = extract_unsigned_integer (&registers[REGISTER_BYTE (regno)],
				     REGISTER_RAW_SIZE (regno));
  strcpy (cmd, "reg ");
  if (!convert_register (regno, &cmd[4]))
    return;
  sprintf (cmd + strlen (cmd), "=0x%x", regval);

  retval = ExeAppReq ("GDB", MWRITEREG, cmd, &null_iob);
  if (retval)
    error ("ExeAppReq returned %d: cmd = %s", retval, cmd);
}

/* Prepare to store registers.  Nothing to do here, since the ICE can write one
   register at a time.  */

static void 
v850ice_prepare_to_store ()
{
}

/* 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
v850ice_xfer_memory (memaddr, myaddr, len, should_write, target)
     CORE_ADDR memaddr;
     char *myaddr;
     int len;
     int should_write;
     struct target_ops *target;			/* ignored */
{
  long retval;
  char cmd[100];
  struct MessageIO iob;

  iob.size = len;
  iob.buf = myaddr;

  if (should_write)
    {
#if 1
      sprintf (cmd, "memory b c 0x%x=0x00 l=%d", (int)memaddr, len);
      retval = ExeAppReq ("GDB", MWRITEBLOCK, cmd, &iob);
#else
      sprintf (cmd, "memory b c 0x%x=0x%x", (int)memaddr, *myaddr & 0xff);
      retval = ExeAppReq ("GDB", MWRITEBLOCK, cmd, &iob);
      return 1;
#endif
    }
  else
    {
      unsigned char *tmp;
      int i;

      tmp = alloca (len + 100);
      memset (tmp + len, 0xff, 100);
      
#if 1
      sprintf (cmd, "memory b 0x%x l=%d", (int)memaddr, len);
      retval = ExeAppReq ("GDB", MREADBLOCK, cmd, &iob);
#else
      sprintf (cmd, "memory h 0x%x", (int)memaddr);
      retval = ExeAppReq ("GDB", MREADMEM, cmd, &iob);
#endif
      for (i = 0; i <  100; i++)
	{
	  if (tmp[len + i] != 0xff)
	    {
	      warning ("MREADBLOCK trashed bytes after transfer area.");
	      break;
	    }
	}
      memcpy (myaddr, tmp, len);
    }

  if (retval)
    error ("ExeAppReq returned %d: cmd = %s", retval, cmd);

  return len;
}

static void
v850ice_files_info (ignore)
     struct target_ops *ignore;
{
  puts_filtered ("Debugging a target via the NEC V850 ICE.\n");
}

static int
v850ice_insert_breakpoint (addr, contents_cache)
     CORE_ADDR addr;
     char *contents_cache;
{
  long retval;
  char cmd[100];

  sprintf (cmd, "%d, ", addr);

#if 1
  retval = ExeAppReq ("GDB", MSETBREAK, cmd, &null_iob);
#else
  retval = ExeAppReq ("GDB", MSETHARDBRK, cmd, &null_iob);
#endif
  if (retval)
    error ("ExeAppReq (MSETBREAK) returned %d: cmd = %s", retval, cmd);

  return 0;
}

static int
v850ice_remove_breakpoint (addr, contents_cache)
     CORE_ADDR addr;
     char *contents_cache;
{
  long retval;
  char cmd[100];

  sprintf (cmd, "%d, ", addr);

#if 1
  retval = ExeAppReq ("GDB", MREMOVEBREAK, cmd, &null_iob);
#else
  retval = ExeAppReq ("GDB", MREMOVEHARDBRK, cmd, &null_iob);
#endif
  if (retval)
    error ("ExeAppReq (MREMOVEBREAK) returned %d: cmd = %s", retval, cmd);

  return 0;
}

static void
v850ice_kill ()
{
  target_mourn_inferior ();
}

static void
v850ice_mourn ()
{
}

/* Define the target subroutine names */


static void init_850ice_ops(void)
{
  v850ice_ops.to_shortname   =   "ice";		
  v850ice_ops.to_longname    =   "NEC V850 ICE interface";
  v850ice_ops.to_doc         =   "Debug a system controlled by a NEC 850 ICE.";
  v850ice_ops.to_open        =   v850ice_open;		
  v850ice_ops.to_close       =   v850ice_close;	
  v850ice_ops.to_attach      =   NULL;		
  v850ice_ops.to_detach      =   v850ice_detach;	
  v850ice_ops.to_resume      =   v850ice_resume;	
  v850ice_ops.to_wait        =   v850ice_wait;	
  v850ice_ops.to_fetch_registers  =   v850ice_fetch_registers;
  v850ice_ops.to_store_registers  =   v850ice_store_registers;
  v850ice_ops.to_prepare_to_store =   v850ice_prepare_to_store;
  v850ice_ops.to_xfer_memory =   v850ice_xfer_memory;	
  v850ice_ops.to_files_info  =   v850ice_files_info;	
  v850ice_ops.to_insert_breakpoint =   v850ice_insert_breakpoint;
  v850ice_ops.to_remove_breakpoint =   v850ice_remove_breakpoint;
  v850ice_ops.to_terminal_init    =   NULL;		
  v850ice_ops.to_terminal_inferior =   NULL;		
  v850ice_ops.to_terminal_ours_for_output =   NULL;	
  v850ice_ops.to_terminal_ours   =   NULL;		
  v850ice_ops.to_terminal_info   =   NULL;		
  v850ice_ops.to_kill            =   v850ice_kill;		
  v850ice_ops.to_load            =   generic_load;		
  v850ice_ops.to_lookup_symbol   =   NULL;		
  v850ice_ops.to_create_inferior =   NULL;		
  v850ice_ops.to_mourn_inferior  =   v850ice_mourn;
  v850ice_ops.to_can_run         =   0;		
  v850ice_ops.to_notice_signals  =   0;		
  v850ice_ops.to_thread_alive    =    NULL;	
  v850ice_ops.to_stop            =   0;			
  v850ice_ops.to_stratum         =   process_stratum;	
  v850ice_ops.DONT_USE           =   NULL;		
  v850ice_ops.to_has_all_memory  =   1;		
  v850ice_ops.to_has_memory      =   1;		
  v850ice_ops.to_has_stack       =   1;		
  v850ice_ops.to_has_registers   =   1;		
  v850ice_ops.to_has_execution   =   1;		
  v850ice_ops.to_sections        =   NULL;		
  v850ice_ops.to_sections_end    =   NULL;		
  v850ice_ops.to_magic           =   OPS_MAGIC	;
}

void
_initialize_v850ice ()
{
  init_850ice_ops() ;
  add_target (&v850ice_ops);
}
Commit	Line	Data
6c310da8 SG	1	/* ICE interface for the NEC V850 for GDB, the GNU debugger.
	2	Copyright 1996, Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20	#include "defs.h"
	21	#include "gdb_string.h"
	22	#if 0
	23	#include "frame.h"
	24	#endif
	25	#include "inferior.h"
	26	#if 0
	27	#include "bfd.h"
	28	#endif
	29	#include "symfile.h"
	30	#include "target.h"
	31	#if 0
	32	#include "wait.h"
	33	#include "gdbcmd.h"
	34	#include "objfiles.h"
	35	#include "gdb-stabs.h"
	36	#include "gdbthread.h"
	37	#endif
264b9de0	38	#define WIN32_LEAN_AND_MEAN
c719b714	39	#include <windows.h>
6c310da8 SG	40
	41	/* Prototypes for local functions */
	42
	43	static void v850ice_files_info PARAMS ((struct target_ops *ignore));
	44
	45	static int v850ice_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr,
	46	int len, int should_write,
	47	struct target_ops *target));
	48
	49	static void v850ice_prepare_to_store PARAMS ((void));
	50
	51	static void v850ice_fetch_registers PARAMS ((int regno));
	52
	53	static void v850ice_resume PARAMS ((int pid, int step,
	54	enum target_signal siggnal));
	55
	56	static void v850ice_open PARAMS ((char *name, int from_tty));
	57
	58	static void v850ice_close PARAMS ((int quitting));
	59
	60	static void v850ice_store_registers PARAMS ((int regno));
	61
	62	static void v850ice_mourn PARAMS ((void));
	63
	64	static int v850ice_wait PARAMS ((int pid, struct target_waitstatus *status));
	65
	66	static void v850ice_kill PARAMS ((void));
	67
	68	static void v850ice_detach PARAMS ((char *args, int from_tty));
	69
	70	static int v850ice_insert_breakpoint PARAMS ((CORE_ADDR, char *));
	71
	72	static int v850ice_remove_breakpoint PARAMS ((CORE_ADDR, char *));
	73
	74	static int ice_open = 0;
	75
c719b714 JM	76	static struct target_ops v850ice_ops ;
c719b714 JM	77
6c310da8 SG	78	#ifndef EXPORT
	79	#define EXPORT __declspec(dllexport)
	80	#endif
	81
264b9de0 SG	82	struct MessageIO
	83	{
	84	int size; /* length of input or output in bytes */
	85	char buf; / buffer having the input/output information */
	86	};
	87
	88	struct MessageIO null_iob = { 0, NULL };
	89
	90	EXPORT long __stdcall ExeAppReq (char , long, char , struct MessageIO *);
	91	EXPORT long __stdcall RegisterClient (HWND);
	92	EXPORT long __stdcall UnregisterClient (void);
	93	EXPORT long __stdcall GdbCallBack (void);
6c310da8 SG	94
	95	#define MREADREG 0x0001
	96	#define MWRITEREG 0x0002
	97	#define MREADMEM 0x0003
	98	#define MWRITEMEM 0x0004
	99	#define MSINGLESTEP 0x0005
	100	#define MRESUME 0x0006
	101	#define MLOADPROGRAM 0x0007
	102	#define MSETBREAK 0x0008
	103	#define MREMOVEBREAK 0x0009
	104	#define MQUIT 0x000A
	105	#define MTERMINATE 0x000B
	106	#define MATTACH 0x000C
	107	#define MCHECKSTATUS 0x000D
	108	#define MHALT 0x000E
	109	#define MDIRECTCMD 0x000F
	110	#define MSYMADR 0x0010
	111	#define MGETTASKLIST 0x0011
	112	#define MREADVECREG 0x0012
	113	#define MWRITEVECREG 0x0013
	114	#define MGETCHANGEDREGS 0x0014
	115	#define MGETSERVERINFO 0x0015
	116	#define MREADBLOCK 0x0016
	117	#define MSETHARDBRK 0x0017
	118	#define MREMOVEHARDBRK 0x0018
	119	#define MCOPYBLOCK 0x0019
	120	#define MBLOCKFILL 0x001A
	121	#define MFINDBLOCK 0x001B
	122	#define MCOMPAREBLOCK 0x001C
	123	#define MREFRESH 0x001D
	124	#define MSPECIAL 0x001E
	125	#define MGETCMDLIST 0x001F
	126	#define MEXPVAL 0x0020
	127	#define MEXPFAILED 0x0021
	128	#define MSAVESTATE 0x0022
	129	#define MWRITEBLOCK 0x0023
	130	#define MDETACH 0x0024
	131	#define MGETMODULES 0x0025
	132	#define MREMOTESYMBOL 0x0026
	133	#define MREADCSTRING 0x0027
	134	#define MLOADMODULE 0x0028
	135	#define MDIDSYSCALL 0x0029
	136	#define MDBPWRITEBUFFERS 0x002A
	137	#define MBPID 0x002B
	138	#define MINITEXEC 0x002C
	139	#define MEXITEXEC 0x002D
	140	#define MRCCMD 0x002E
	141	#define MDOWNLOAD 0x0050
	142
264b9de0 SG	143	#define StatRunning 0
	144	#define StatExecBreak 1 /* an execution breakpoint has been reached */
	145	#define StatStepped 2 /* a single step has been completed */
	146	#define StatException 3 /* the target has stopped due to an exception */
	147	#define StatHalted 4 /* target has been halted by a user request */
	148	#define StatExited 5 /* target called exit */
	149	#define StatTerminated 6 /* target program terminated by a user request */
	150	#define StatNoProcess 7 /* no process on target and none of the above */
	151	#define StatNeedInput 8 /* REV: obsolete */
	152	#define StatNeedDirCmd 9 /* waiting for an entry in the remote window */
	153	#define StatHardBreak 10 /* hit hardware breakpoint */
	154	#define StatFailure 11 /* an error occured in the last run/single */
	155
6c310da8 SG	156
	157	/* "pir", "tkcw", "chcw", "adtre" */
	158
	159	/* Code for opening a connection to the ICE. */
	160
	161	static void
	162	v850ice_open (name, from_tty)
	163	char *name;
	164	int from_tty;
	165	{
	166	long retval;
6c310da8 SG	167
	168	if (name)
	169	error ("Too many arguments.");
	170
	171	target_preopen (from_tty);
	172
	173	unpush_target (&v850ice_ops);
	174
	175	if (from_tty)
	176	puts_filtered ("V850ice debugging\n");
	177
	178	push_target (&v850ice_ops); /* Switch to using v850ice target now */
	179
	180	target_terminal_init ();
	181
	182	/* Without this, some commands which require an active target (such as kill)
	183	won't work. This variable serves (at least) double duty as both the pid
	184	of the target process (if it has such), and as a flag indicating that a
	185	target is active. These functions should be split out into seperate
	186	variables, especially since GDB will someday have a notion of debugging
	187	several processes. */
	188
	189	inferior_pid = 42000;
	190
	191	/* Start the v850ice connection; if error (0), discard this target.
	192	In particular, if the user quits, be sure to discard it
	193	(we'd be in an inconsistent state otherwise). */
	194
264b9de0 SG	195	WinExec ("necsrv", SW_SHOW); /* Start up necsrv */
	196
	197	retval = RegisterClient (NULL);
	198
	199	if (retval == 0)
	200	{
	201	ice_open = 1;
	202
	203	start_remote ();
	204	return;
	205	}
6c310da8	206
264b9de0	207	pop_target();
6c310da8	208
264b9de0	209	error ("v850ice_open: MINITEXEC return error: 0x%x", retval);
6c310da8 SG	210	}
	211
	212	/* Clean up connection to a remote debugger. */
	213
	214	/* ARGSUSED */
	215	static void
	216	v850ice_close (quitting)
	217	int quitting;
	218	{
	219	long retval;
	220
	221	if (ice_open)
	222	{
264b9de0 SG	223	#if 0
264b9de0 SG	224	retval = ExeAppReq ("GDB", MEXITEXEC, NULL, &null_iob);
6c310da8 SG	225	if (retval)
6c310da8 SG	226	error ("ExeAppReq (MEXITEXEC) returned %d", retval);
264b9de0	227	#endif
6c310da8	228	ice_open = 0;
264b9de0	229	UnregisterClient ();
6c310da8 SG	230	}
	231	}
	232
	233	static void
	234	v850ice_detach (args, from_tty)
	235	char *args;
	236	int from_tty;
	237	{
	238	if (args)
	239	error ("Argument given to \"detach\" when remotely debugging.");
	240
	241	pop_target ();
	242	if (from_tty)
	243	puts_filtered ("Ending v850ice debugging.\n");
	244	}
	245
	246	/* Tell the remote machine to resume. */
	247
	248	static void
	249	v850ice_resume (pid, step, siggnal)
	250	int pid, step;
	251	enum target_signal siggnal;
	252	{
	253	long retval;
6c310da8 SG	254
6c310da8 SG	255	if (step)
264b9de0	256	retval = ExeAppReq ("GDB", MSINGLESTEP, "step", &null_iob);
6c310da8	257	else
264b9de0	258	retval = ExeAppReq ("GDB", MRESUME, "run", &null_iob);
6c310da8 SG	259
6c310da8 SG	260	if (retval)
264b9de0	261	error ("ExeAppReq (step = %d) returned %d", step, retval);
6c310da8 SG	262	}
	263
	264	/* Wait until the remote machine stops, then return,
	265	storing status in STATUS just as `wait' would.
	266	Returns "pid" (though it's not clear what, if anything, that
	267	means in the case of this target). */
	268
	269	static int
	270	v850ice_wait (pid, status)
	271	int pid;
	272	struct target_waitstatus *status;
	273	{
264b9de0 SG	274	long v850_status;
	275
	276	v850_status = ExeAppReq ("GDB", MCHECKSTATUS, NULL, &null_iob);
	277
6c310da8 SG	278	status->kind = TARGET_WAITKIND_STOPPED;
	279	status->value.sig = TARGET_SIGNAL_TRAP;
	280
	281	return inferior_pid;
	282	}
	283
	284	static int
	285	convert_register (regno, buf)
	286	int regno;
	287	char *buf;
	288	{
	289	if (regno <= 31)
	290	sprintf (buf, "r%d", regno);
	291	else if (reg_names[regno][0] == 's'
	292	&& reg_names[regno][1] == 'r')
	293	return 0;
	294	else
	295	sprintf (buf, "%s", reg_names[regno]);
	296
	297	return 1;
	298	}
	299
	300	/* Read the remote registers into the block REGS. */
	301	/* Note that the ICE returns register contents as ascii hex strings. We have
	302	to convert that to an unsigned long, and then call store_unsigned_integer to
	303	convert it to target byte-order if necessary. */
	304
	305	static void
	306	v850ice_fetch_registers (regno)
	307	int regno;
	308	{
	309	long retval;
	310	char cmd[100];
	311	char val[100];
264b9de0	312	struct MessageIO iob;
6c310da8 SG	313	unsigned long regval;
	314	char *p;
	315
	316	if (regno == -1)
	317	{
	318	for (regno = 0; regno < NUM_REGS; regno++)
	319	v850ice_fetch_registers (regno);
	320	return;
	321	}
	322
	323	strcpy (cmd, "reg ");
	324	if (!convert_register (regno, &cmd[4]))
	325	return;
	326
264b9de0 SG	327	iob.size = sizeof val;
	328	iob.buf = val;
	329	retval = ExeAppReq ("GDB", MREADREG, cmd, &iob);
6c310da8 SG	330	if (retval)
	331	error ("ExeAppReq returned %d: cmd = %s", retval, cmd);
	332
	333	regval = strtoul (val, &p, 16);
	334	if (regval == 0 && p == val)
	335	error ("v850ice_fetch_registers (%d): bad value from ICE: %s.",
	336	regno, val);
	337
	338	store_unsigned_integer (val, REGISTER_RAW_SIZE (regno), regval);
	339	supply_register (regno, val);
	340	}
	341
	342	/* Store register REGNO, or all registers if REGNO == -1, from the contents
	343	of REGISTERS. */
	344
	345	static void
	346	v850ice_store_registers (regno)
	347	int regno;
	348	{
	349	long retval;
	350	char cmd[100];
6c310da8 SG	351	unsigned long regval;
	352
	353	if (regno == -1)
	354	{
	355	for (regno = 0; regno < NUM_REGS; regno++)
	356	v850ice_store_registers (regno);
	357	return;
	358	}
	359
	360	regval = extract_unsigned_integer (&registers[REGISTER_BYTE (regno)],
	361	REGISTER_RAW_SIZE (regno));
	362	strcpy (cmd, "reg ");
	363	if (!convert_register (regno, &cmd[4]))
	364	return;
	365	sprintf (cmd + strlen (cmd), "=0x%x", regval);
	366
264b9de0	367	retval = ExeAppReq ("GDB", MWRITEREG, cmd, &null_iob);
6c310da8 SG	368	if (retval)
	369	error ("ExeAppReq returned %d: cmd = %s", retval, cmd);
	370	}
	371
	372	/* Prepare to store registers. Nothing to do here, since the ICE can write one
	373	register at a time. */
	374
	375	static void
	376	v850ice_prepare_to_store ()
	377	{
	378	}
	379
	380	/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
	381	to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
	382	nonzero. Returns length of data written or read; 0 for error. */
	383
	384	/* ARGSUSED */
	385	static int
	386	v850ice_xfer_memory (memaddr, myaddr, len, should_write, target)
	387	CORE_ADDR memaddr;
	388	char *myaddr;
	389	int len;
	390	int should_write;
	391	struct target_ops target; / ignored */
	392	{
	393	long retval;
	394	char cmd[100];
264b9de0 SG	395	struct MessageIO iob;
	396
	397	iob.size = len;
	398	iob.buf = myaddr;
6c310da8 SG	399
	400	if (should_write)
	401	{
	402	#if 1
	403	sprintf (cmd, "memory b c 0x%x=0x00 l=%d", (int)memaddr, len);
264b9de0	404	retval = ExeAppReq ("GDB", MWRITEBLOCK, cmd, &iob);
6c310da8 SG	405	#else
6c310da8 SG	406	sprintf (cmd, "memory b c 0x%x=0x%x", (int)memaddr, *myaddr & 0xff);
264b9de0	407	retval = ExeAppReq ("GDB", MWRITEBLOCK, cmd, &iob);
6c310da8 SG	408	return 1;
	409	#endif
	410	}
	411	else
	412	{
	413	unsigned char *tmp;
	414	int i;
	415
	416	tmp = alloca (len + 100);
	417	memset (tmp + len, 0xff, 100);
	418
264b9de0	419	#if 1
6c310da8	420	sprintf (cmd, "memory b 0x%x l=%d", (int)memaddr, len);
264b9de0 SG	421	retval = ExeAppReq ("GDB", MREADBLOCK, cmd, &iob);
	422	#else
	423	sprintf (cmd, "memory h 0x%x", (int)memaddr);
	424	retval = ExeAppReq ("GDB", MREADMEM, cmd, &iob);
	425	#endif
6c310da8 SG	426	for (i = 0; i < 100; i++)
	427	{
	428	if (tmp[len + i] != 0xff)
	429	{
	430	warning ("MREADBLOCK trashed bytes after transfer area.");
	431	break;
	432	}
	433	}
	434	memcpy (myaddr, tmp, len);
	435	}
	436
	437	if (retval)
	438	error ("ExeAppReq returned %d: cmd = %s", retval, cmd);
	439
	440	return len;
	441	}
	442
	443	static void
	444	v850ice_files_info (ignore)
	445	struct target_ops *ignore;
	446	{
	447	puts_filtered ("Debugging a target via the NEC V850 ICE.\n");
	448	}
	449
	450	static int
	451	v850ice_insert_breakpoint (addr, contents_cache)
	452	CORE_ADDR addr;
	453	char *contents_cache;
	454	{
	455	long retval;
	456	char cmd[100];
6c310da8 SG	457
	458	sprintf (cmd, "%d, ", addr);
	459
	460	#if 1
264b9de0	461	retval = ExeAppReq ("GDB", MSETBREAK, cmd, &null_iob);
6c310da8	462	#else
264b9de0	463	retval = ExeAppReq ("GDB", MSETHARDBRK, cmd, &null_iob);
6c310da8 SG	464	#endif
	465	if (retval)
	466	error ("ExeAppReq (MSETBREAK) returned %d: cmd = %s", retval, cmd);
	467
	468	return 0;
	469	}
	470
	471	static int
	472	v850ice_remove_breakpoint (addr, contents_cache)
	473	CORE_ADDR addr;
	474	char *contents_cache;
	475	{
	476	long retval;
	477	char cmd[100];
6c310da8 SG	478
	479	sprintf (cmd, "%d, ", addr);
	480
	481	#if 1
264b9de0	482	retval = ExeAppReq ("GDB", MREMOVEBREAK, cmd, &null_iob);
6c310da8	483	#else
264b9de0	484	retval = ExeAppReq ("GDB", MREMOVEHARDBRK, cmd, &null_iob);
6c310da8 SG	485	#endif
	486	if (retval)
	487	error ("ExeAppReq (MREMOVEBREAK) returned %d: cmd = %s", retval, cmd);
	488
	489	return 0;
	490	}
	491
	492	static void
	493	v850ice_kill ()
	494	{
	495	target_mourn_inferior ();
	496	}
	497
	498	static void
	499	v850ice_mourn ()
	500	{
	501	}
	502
	503	/* Define the target subroutine names */
	504
c719b714 JM	505
	506	static void init_850ice_ops(void)
	507	{
	508	v850ice_ops.to_shortname = "ice";
	509	v850ice_ops.to_longname = "NEC V850 ICE interface";
	510	v850ice_ops.to_doc = "Debug a system controlled by a NEC 850 ICE.";
	511	v850ice_ops.to_open = v850ice_open;
	512	v850ice_ops.to_close = v850ice_close;
	513	v850ice_ops.to_attach = NULL;
	514	v850ice_ops.to_detach = v850ice_detach;
	515	v850ice_ops.to_resume = v850ice_resume;
	516	v850ice_ops.to_wait = v850ice_wait;
	517	v850ice_ops.to_fetch_registers = v850ice_fetch_registers;
	518	v850ice_ops.to_store_registers = v850ice_store_registers;
	519	v850ice_ops.to_prepare_to_store = v850ice_prepare_to_store;
	520	v850ice_ops.to_xfer_memory = v850ice_xfer_memory;
	521	v850ice_ops.to_files_info = v850ice_files_info;
	522	v850ice_ops.to_insert_breakpoint = v850ice_insert_breakpoint;
	523	v850ice_ops.to_remove_breakpoint = v850ice_remove_breakpoint;
	524	v850ice_ops.to_terminal_init = NULL;
	525	v850ice_ops.to_terminal_inferior = NULL;
	526	v850ice_ops.to_terminal_ours_for_output = NULL;
	527	v850ice_ops.to_terminal_ours = NULL;
	528	v850ice_ops.to_terminal_info = NULL;
	529	v850ice_ops.to_kill = v850ice_kill;
	530	v850ice_ops.to_load = generic_load;
	531	v850ice_ops.to_lookup_symbol = NULL;
	532	v850ice_ops.to_create_inferior = NULL;
	533	v850ice_ops.to_mourn_inferior = v850ice_mourn;
	534	v850ice_ops.to_can_run = 0;
	535	v850ice_ops.to_notice_signals = 0;
	536	v850ice_ops.to_thread_alive = NULL;
	537	v850ice_ops.to_stop = 0;
	538	v850ice_ops.to_stratum = process_stratum;
	539	v850ice_ops.DONT_USE = NULL;
	540	v850ice_ops.to_has_all_memory = 1;
	541	v850ice_ops.to_has_memory = 1;
	542	v850ice_ops.to_has_stack = 1;
	543	v850ice_ops.to_has_registers = 1;
	544	v850ice_ops.to_has_execution = 1;
	545	v850ice_ops.to_sections = NULL;
	546	v850ice_ops.to_sections_end = NULL;
	547	v850ice_ops.to_magic = OPS_MAGIC ;
	548	}
6c310da8 SG	549
	550	void
	551	_initialize_v850ice ()
	552	{
c719b714	553	init_850ice_ops() ;
6c310da8 SG	554	add_target (&v850ice_ops);
6c310da8 SG	555	}