[deliverable/binutils-gdb.git] / gdb / cpu32bug-rom.c

/* Remote debugging interface for CPU32Bug Rom monitor for GDB, the GNU debugger.
   Copyright 1995, 1996, 1998, 1999, 2000, 2001
   Free Software Foundation, Inc.

   Written by Stu Grossman of Cygnus Support

   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 "gdbcore.h"
#include "target.h"
#include "monitor.h"
#include "serial.h"
#include "regcache.h"

#include "m68k-tdep.h"

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

static void
cpu32bug_supply_register (char *regname, int regnamelen, char *val, int vallen)
{
  int regno;

  if (regnamelen != 2)
    return;

  switch (regname[0])
    {
    case 'S':
      if (regname[1] != 'R')
	return;
      regno = PS_REGNUM;
      break;
    case 'P':
      if (regname[1] != 'C')
	return;
      regno = PC_REGNUM;
      break;
    case 'D':
      if (regname[1] < '0' || regname[1] > '7')
	return;
      regno = regname[1] - '0' + M68K_D0_REGNUM;
      break;
    case 'A':
      if (regname[1] < '0' || regname[1] > '7')
	return;
      regno = regname[1] - '0' + M68K_A0_REGNUM;
      break;
    default:
      return;
    }

  monitor_supply_register (regno, val);
}

/*
 * This array of registers needs to match the indexes used by GDB. The
 * whole reason this exists is because the various ROM monitors use
 * different names than GDB does, and don't support all the
 * registers either. So, typing "info reg sp" becomes an "A7".
 */

static const char *
cpu32bug_regname (int index)
{
  static char *regnames[] =
  {
    "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
    "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
    "SR", "PC"
  };

  if ((index >= (sizeof (regnames) / sizeof (regnames[0]))) 
       || (index < 0) || (index >= NUM_REGS))
    return NULL;
  else
    return regnames[index];
}

/*
 * Define the monitor command strings. Since these are passed directly
 * through to a printf style function, we need can include formatting
 * strings. We also need a CR or LF on the end.
 */

static struct target_ops cpu32bug_ops;

static char *cpu32bug_inits[] =
{"\r", NULL};

static struct monitor_ops cpu32bug_cmds;

static void
init_cpu32bug_cmds (void)
{
  cpu32bug_cmds.flags = MO_CLR_BREAK_USES_ADDR;
  cpu32bug_cmds.init = cpu32bug_inits;	/* Init strings */
  cpu32bug_cmds.cont = "g\r";	/* continue command */
  cpu32bug_cmds.step = "t\r";	/* single step */
  cpu32bug_cmds.stop = NULL;	/* interrupt command */
  cpu32bug_cmds.set_break = "br %x\r";	/* set a breakpoint */
  cpu32bug_cmds.clr_break = "nobr %x\r";	/* clear a breakpoint */
  cpu32bug_cmds.clr_all_break = "nobr\r";	/* clear all breakpoints */
  cpu32bug_cmds.fill = "bf %x:%x %x;b\r";	/* fill (start count val) */
  cpu32bug_cmds.setmem.cmdb = "ms %x %02x\r";	/* setmem.cmdb (addr, value) */
  cpu32bug_cmds.setmem.cmdw = "ms %x %04x\r";	/* setmem.cmdw (addr, value) */
  cpu32bug_cmds.setmem.cmdl = "ms %x %08x\r";	/* setmem.cmdl (addr, value) */
  cpu32bug_cmds.setmem.cmdll = NULL;	/* setmem.cmdll (addr, value) */
  cpu32bug_cmds.setmem.resp_delim = NULL;	/* setreg.resp_delim */
  cpu32bug_cmds.setmem.term = NULL;	/* setreg.term */
  cpu32bug_cmds.setmem.term_cmd = NULL;		/* setreg.term_cmd */
  cpu32bug_cmds.getmem.cmdb = "md %x:%x;b\r";	/* getmem.cmdb (addr, len) */
  cpu32bug_cmds.getmem.cmdw = "md %x:%x;b\r";	/* getmem.cmdw (addr, len) */
  cpu32bug_cmds.getmem.cmdl = "md %x:%x;b\r";	/* getmem.cmdl (addr, len) */
  cpu32bug_cmds.getmem.cmdll = NULL;	/* getmem.cmdll (addr, len) */
  cpu32bug_cmds.getmem.resp_delim = " ";	/* getmem.resp_delim */
  cpu32bug_cmds.getmem.term = NULL;	/* getmem.term */
  cpu32bug_cmds.getmem.term_cmd = NULL;		/* getmem.term_cmd */
  cpu32bug_cmds.setreg.cmd = "rs %s %x\r";	/* setreg.cmd (name, value) */
  cpu32bug_cmds.setreg.resp_delim = NULL;	/* setreg.resp_delim */
  cpu32bug_cmds.setreg.term = NULL;	/* setreg.term */
  cpu32bug_cmds.setreg.term_cmd = NULL;		/* setreg.term_cmd */
  cpu32bug_cmds.getreg.cmd = "rs %s\r";		/* getreg.cmd (name) */
  cpu32bug_cmds.getreg.resp_delim = "=";	/* getreg.resp_delim */
  cpu32bug_cmds.getreg.term = NULL;	/* getreg.term */
  cpu32bug_cmds.getreg.term_cmd = NULL;		/* getreg.term_cmd */
  cpu32bug_cmds.dump_registers = "rd\r";	/* dump_registers */
  cpu32bug_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)";	/* register_pattern */
  cpu32bug_cmds.supply_register = cpu32bug_supply_register;
  cpu32bug_cmds.load_routine = NULL;	/* load_routine (defaults to SRECs) */
  cpu32bug_cmds.load = "lo\r";	/* download command */
  cpu32bug_cmds.loadresp = "\n";	/* load response */
  cpu32bug_cmds.prompt = "CPU32Bug>";	/* monitor command prompt */
  cpu32bug_cmds.line_term = "\r";	/* end-of-line terminator */
  cpu32bug_cmds.cmd_end = NULL;	/* optional command terminator */
  cpu32bug_cmds.target = &cpu32bug_ops;		/* target operations */
  cpu32bug_cmds.stopbits = SERIAL_1_STOPBITS;	/* number of stop bits */
  cpu32bug_cmds.regnames = NULL;	/* registers names */
  cpu32bug_cmds.regname = cpu32bug_regname;
  cpu32bug_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
};				/* init_cpu32bug_cmds */

static void
cpu32bug_open (char *args, int from_tty)
{
  monitor_open (args, &cpu32bug_cmds, from_tty);
}

extern initialize_file_ftype _initialize_cpu32bug_rom; /* -Wmissing-prototypes */

void
_initialize_cpu32bug_rom (void)
{
  init_cpu32bug_cmds ();
  init_monitor_ops (&cpu32bug_ops);

  cpu32bug_ops.to_shortname = "cpu32bug";
  cpu32bug_ops.to_longname = "CPU32Bug monitor";
  cpu32bug_ops.to_doc = "Debug via the CPU32Bug monitor.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  cpu32bug_ops.to_open = cpu32bug_open;

  add_target (&cpu32bug_ops);
}
Commit	Line	Data
c906108c	1	/* Remote debugging interface for CPU32Bug Rom monitor for GDB, the GNU debugger.
b6ba6518 KB	2	Copyright 1995, 1996, 1998, 1999, 2000, 2001
b6ba6518 KB	3	Free Software Foundation, Inc.
c906108c SS	4
	5	Written by Stu Grossman of Cygnus Support
	6
c5aa993b	7	This file is part of GDB.
c906108c	8
c5aa993b JM	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
c906108c	13
c5aa993b JM	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
c906108c	18
c5aa993b JM	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 59 Temple Place - Suite 330,
	22	Boston, MA 02111-1307, USA. */
c906108c SS	23
	24	#include "defs.h"
	25	#include "gdbcore.h"
	26	#include "target.h"
	27	#include "monitor.h"
	28	#include "serial.h"
4e052eda	29	#include "regcache.h"
c906108c	30
32eeb91a AS	31	#include "m68k-tdep.h"
32eeb91a AS	32
a14ed312	33	static void cpu32bug_open (char *args, int from_tty);
c906108c SS	34
c906108c SS	35	static void
fba45db2	36	cpu32bug_supply_register (char regname, int regnamelen, char val, int vallen)
c906108c SS	37	{
	38	int regno;
	39
	40	if (regnamelen != 2)
	41	return;
	42
	43	switch (regname[0])
	44	{
	45	case 'S':
	46	if (regname[1] != 'R')
	47	return;
	48	regno = PS_REGNUM;
	49	break;
	50	case 'P':
	51	if (regname[1] != 'C')
	52	return;
	53	regno = PC_REGNUM;
	54	break;
	55	case 'D':
	56	if (regname[1] < '0' \|\| regname[1] > '7')
	57	return;
32eeb91a	58	regno = regname[1] - '0' + M68K_D0_REGNUM;
c906108c SS	59	break;
	60	case 'A':
	61	if (regname[1] < '0' \|\| regname[1] > '7')
	62	return;
32eeb91a	63	regno = regname[1] - '0' + M68K_A0_REGNUM;
c906108c SS	64	break;
	65	default:
	66	return;
	67	}
	68
	69	monitor_supply_register (regno, val);
	70	}
	71
	72	/*
	73	* This array of registers needs to match the indexes used by GDB. The
	74	* whole reason this exists is because the various ROM monitors use
	75	* different names than GDB does, and don't support all the
	76	* registers either. So, typing "info reg sp" becomes an "A7".
	77	*/
	78
1c617db8 GS	79	static const char *
1c617db8 GS	80	cpu32bug_regname (int index)
c906108c	81	{
1c617db8 GS	82	static char *regnames[] =
	83	{
	84	"D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
	85	"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
	86	"SR", "PC"
	87	};
	88
	89	if ((index >= (sizeof (regnames) / sizeof (regnames[0])))
	90	\|\| (index < 0) \|\| (index >= NUM_REGS))
	91	return NULL;
	92	else
	93	return regnames[index];
	94	}
c906108c SS	95
	96	/*
	97	* Define the monitor command strings. Since these are passed directly
	98	* through to a printf style function, we need can include formatting
	99	* strings. We also need a CR or LF on the end.
	100	*/
	101
	102	static struct target_ops cpu32bug_ops;
	103
c5aa993b JM	104	static char *cpu32bug_inits[] =
c5aa993b JM	105	{"\r", NULL};
c906108c	106
c5aa993b	107	static struct monitor_ops cpu32bug_cmds;
c906108c	108
c5aa993b JM	109	static void
c5aa993b JM	110	init_cpu32bug_cmds (void)
c906108c	111	{
c5aa993b JM	112	cpu32bug_cmds.flags = MO_CLR_BREAK_USES_ADDR;
	113	cpu32bug_cmds.init = cpu32bug_inits; /* Init strings */
	114	cpu32bug_cmds.cont = "g\r"; /* continue command */
	115	cpu32bug_cmds.step = "t\r"; /* single step */
	116	cpu32bug_cmds.stop = NULL; /* interrupt command */
	117	cpu32bug_cmds.set_break = "br %x\r"; /* set a breakpoint */
	118	cpu32bug_cmds.clr_break = "nobr %x\r"; /* clear a breakpoint */
	119	cpu32bug_cmds.clr_all_break = "nobr\r"; /* clear all breakpoints */
	120	cpu32bug_cmds.fill = "bf %x:%x %x;b\r"; /* fill (start count val) */
	121	cpu32bug_cmds.setmem.cmdb = "ms %x %02x\r"; /* setmem.cmdb (addr, value) */
	122	cpu32bug_cmds.setmem.cmdw = "ms %x %04x\r"; /* setmem.cmdw (addr, value) */
	123	cpu32bug_cmds.setmem.cmdl = "ms %x %08x\r"; /* setmem.cmdl (addr, value) */
	124	cpu32bug_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */
	125	cpu32bug_cmds.setmem.resp_delim = NULL; /* setreg.resp_delim */
	126	cpu32bug_cmds.setmem.term = NULL; /* setreg.term */
	127	cpu32bug_cmds.setmem.term_cmd = NULL; /* setreg.term_cmd */
	128	cpu32bug_cmds.getmem.cmdb = "md %x:%x;b\r"; /* getmem.cmdb (addr, len) */
	129	cpu32bug_cmds.getmem.cmdw = "md %x:%x;b\r"; /* getmem.cmdw (addr, len) */
	130	cpu32bug_cmds.getmem.cmdl = "md %x:%x;b\r"; /* getmem.cmdl (addr, len) */
	131	cpu32bug_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */
	132	cpu32bug_cmds.getmem.resp_delim = " "; /* getmem.resp_delim */
	133	cpu32bug_cmds.getmem.term = NULL; /* getmem.term */
	134	cpu32bug_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */
	135	cpu32bug_cmds.setreg.cmd = "rs %s %x\r"; /* setreg.cmd (name, value) */
	136	cpu32bug_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */
	137	cpu32bug_cmds.setreg.term = NULL; /* setreg.term */
	138	cpu32bug_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */
	139	cpu32bug_cmds.getreg.cmd = "rs %s\r"; /* getreg.cmd (name) */
	140	cpu32bug_cmds.getreg.resp_delim = "="; /* getreg.resp_delim */
	141	cpu32bug_cmds.getreg.term = NULL; /* getreg.term */
	142	cpu32bug_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
	143	cpu32bug_cmds.dump_registers = "rd\r"; /* dump_registers */
	144	cpu32bug_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
23a6d369	145	cpu32bug_cmds.supply_register = cpu32bug_supply_register;
c5aa993b JM	146	cpu32bug_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
	147	cpu32bug_cmds.load = "lo\r"; /* download command */
	148	cpu32bug_cmds.loadresp = "\n"; /* load response */
	149	cpu32bug_cmds.prompt = "CPU32Bug>"; /* monitor command prompt */
	150	cpu32bug_cmds.line_term = "\r"; /* end-of-line terminator */
	151	cpu32bug_cmds.cmd_end = NULL; /* optional command terminator */
	152	cpu32bug_cmds.target = &cpu32bug_ops; /* target operations */
	153	cpu32bug_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */
1c617db8 GS	154	cpu32bug_cmds.regnames = NULL; /* registers names */
1c617db8 GS	155	cpu32bug_cmds.regname = cpu32bug_regname;
c5aa993b JM	156	cpu32bug_cmds.magic = MONITOR_OPS_MAGIC; /* magic */
c5aa993b JM	157	}; /* init_cpu32bug_cmds */
c906108c SS	158
c906108c SS	159	static void
fba45db2	160	cpu32bug_open (char *args, int from_tty)
c906108c SS	161	{
	162	monitor_open (args, &cpu32bug_cmds, from_tty);
	163	}
	164
a78f21af AC	165	extern initialize_file_ftype _initialize_cpu32bug_rom; /* -Wmissing-prototypes */
a78f21af AC	166
c906108c	167	void
fba45db2	168	_initialize_cpu32bug_rom (void)
c906108c	169	{
c5aa993b	170	init_cpu32bug_cmds ();
c906108c SS	171	init_monitor_ops (&cpu32bug_ops);
	172
	173	cpu32bug_ops.to_shortname = "cpu32bug";
	174	cpu32bug_ops.to_longname = "CPU32Bug monitor";
	175	cpu32bug_ops.to_doc = "Debug via the CPU32Bug monitor.\n\
	176	Specify the serial device it is connected to (e.g. /dev/ttya).";
	177	cpu32bug_ops.to_open = cpu32bug_open;
	178
	179	add_target (&cpu32bug_ops);
	180	}