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

/* Remote debugging interface for CPU32Bug Rom monitor for GDB, the GNU debugger.
   Copyright 1995 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"

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

static void
cpu32bug_supply_register (regname, regnamelen, val, vallen)
     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' + D0_REGNUM;
      break;
    case 'A':
      if (regname[1] < '0' || regname[1] > '7')
	return;
      regno = regname[1] - '0' + 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 char *cpu32bug_regnames[NUM_REGS] =
{
  "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
  "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
  "SR", "PC",
};

/*
 * 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;	/* 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 = cpu32bug_regnames;	/* registers names */
  cpu32bug_cmds.magic = MONITOR_OPS_MAGIC;	/* magic */
};				/* init_cpu32bug_cmds */

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

void
_initialize_cpu32bug_rom ()
{
  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 SS	1	/* Remote debugging interface for CPU32Bug Rom monitor for GDB, the GNU debugger.
	2	Copyright 1995 Free Software Foundation, Inc.
	3
	4	Written by Stu Grossman of Cygnus Support
	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
c906108c	12
c5aa993b JM	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
c906108c	17
c5aa993b JM	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
c906108c SS	22
	23	#include "defs.h"
	24	#include "gdbcore.h"
	25	#include "target.h"
	26	#include "monitor.h"
	27	#include "serial.h"
	28
	29	static void cpu32bug_open PARAMS ((char *args, int from_tty));
	30
	31	static void
	32	cpu32bug_supply_register (regname, regnamelen, val, vallen)
	33	char *regname;
	34	int regnamelen;
	35	char *val;
	36	int vallen;
	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;
	58	regno = regname[1] - '0' + D0_REGNUM;
	59	break;
	60	case 'A':
	61	if (regname[1] < '0' \|\| regname[1] > '7')
	62	return;
	63	regno = regname[1] - '0' + A0_REGNUM;
	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
	79	static char *cpu32bug_regnames[NUM_REGS] =
	80	{
	81	"D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
	82	"A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
	83	"SR", "PC",
	84	};
	85
86	/*
87	* Define the monitor command strings. Since these are passed directly
88	* through to a printf style function, we need can include formatting
89	* strings. We also need a CR or LF on the end.
90	*/
91
92	static struct target_ops cpu32bug_ops;
93
c5aa993b JM	94	static char *cpu32bug_inits[] =
c5aa993b JM	95	{"\r", NULL};
c906108c	96
c5aa993b	97	static struct monitor_ops cpu32bug_cmds;
c906108c	98
c5aa993b JM	99	static void
c5aa993b JM	100	init_cpu32bug_cmds (void)
c906108c	101	{
c5aa993b JM	102	cpu32bug_cmds.flags = MO_CLR_BREAK_USES_ADDR;
	103	cpu32bug_cmds.init = cpu32bug_inits; /* Init strings */
	104	cpu32bug_cmds.cont = "g\r"; /* continue command */
	105	cpu32bug_cmds.step = "t\r"; /* single step */
	106	cpu32bug_cmds.stop = NULL; /* interrupt command */
	107	cpu32bug_cmds.set_break = "br %x\r"; /* set a breakpoint */
	108	cpu32bug_cmds.clr_break = "nobr %x\r"; /* clear a breakpoint */
	109	cpu32bug_cmds.clr_all_break = "nobr\r"; /* clear all breakpoints */
	110	cpu32bug_cmds.fill = "bf %x:%x %x;b\r"; /* fill (start count val) */
	111	cpu32bug_cmds.setmem.cmdb = "ms %x %02x\r"; /* setmem.cmdb (addr, value) */
	112	cpu32bug_cmds.setmem.cmdw = "ms %x %04x\r"; /* setmem.cmdw (addr, value) */
	113	cpu32bug_cmds.setmem.cmdl = "ms %x %08x\r"; /* setmem.cmdl (addr, value) */
	114	cpu32bug_cmds.setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */
	115	cpu32bug_cmds.setmem.resp_delim = NULL; /* setreg.resp_delim */
	116	cpu32bug_cmds.setmem.term = NULL; /* setreg.term */
	117	cpu32bug_cmds.setmem.term_cmd = NULL; /* setreg.term_cmd */
	118	cpu32bug_cmds.getmem.cmdb = "md %x:%x;b\r"; /* getmem.cmdb (addr, len) */
	119	cpu32bug_cmds.getmem.cmdw = "md %x:%x;b\r"; /* getmem.cmdw (addr, len) */
	120	cpu32bug_cmds.getmem.cmdl = "md %x:%x;b\r"; /* getmem.cmdl (addr, len) */
	121	cpu32bug_cmds.getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */
	122	cpu32bug_cmds.getmem.resp_delim = " "; /* getmem.resp_delim */
	123	cpu32bug_cmds.getmem.term = NULL; /* getmem.term */
	124	cpu32bug_cmds.getmem.term_cmd = NULL; /* getmem.term_cmd */
	125	cpu32bug_cmds.setreg.cmd = "rs %s %x\r"; /* setreg.cmd (name, value) */
	126	cpu32bug_cmds.setreg.resp_delim = NULL; /* setreg.resp_delim */
	127	cpu32bug_cmds.setreg.term = NULL; /* setreg.term */
	128	cpu32bug_cmds.setreg.term_cmd = NULL; /* setreg.term_cmd */
	129	cpu32bug_cmds.getreg.cmd = "rs %s\r"; /* getreg.cmd (name) */
	130	cpu32bug_cmds.getreg.resp_delim = "="; /* getreg.resp_delim */
	131	cpu32bug_cmds.getreg.term = NULL; /* getreg.term */
	132	cpu32bug_cmds.getreg.term_cmd = NULL; /* getreg.term_cmd */
	133	cpu32bug_cmds.dump_registers = "rd\r"; /* dump_registers */
	134	cpu32bug_cmds.register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
	135	cpu32bug_cmds.supply_register = cpu32bug_supply_register; /* supply_register */
	136	cpu32bug_cmds.load_routine = NULL; /* load_routine (defaults to SRECs) */
	137	cpu32bug_cmds.load = "lo\r"; /* download command */
	138	cpu32bug_cmds.loadresp = "\n"; /* load response */
	139	cpu32bug_cmds.prompt = "CPU32Bug>"; /* monitor command prompt */
	140	cpu32bug_cmds.line_term = "\r"; /* end-of-line terminator */
	141	cpu32bug_cmds.cmd_end = NULL; /* optional command terminator */
	142	cpu32bug_cmds.target = &cpu32bug_ops; /* target operations */
	143	cpu32bug_cmds.stopbits = SERIAL_1_STOPBITS; /* number of stop bits */
	144	cpu32bug_cmds.regnames = cpu32bug_regnames; /* registers names */
	145	cpu32bug_cmds.magic = MONITOR_OPS_MAGIC; /* magic */
	146	}; /* init_cpu32bug_cmds */
c906108c SS	147
c906108c SS	148	static void
c5aa993b	149	cpu32bug_open (args, from_tty)
c906108c SS	150	char *args;
	151	int from_tty;
	152	{
	153	monitor_open (args, &cpu32bug_cmds, from_tty);
	154	}
	155
	156	void
	157	_initialize_cpu32bug_rom ()
	158	{
c5aa993b	159	init_cpu32bug_cmds ();
c906108c SS	160	init_monitor_ops (&cpu32bug_ops);
	161
	162	cpu32bug_ops.to_shortname = "cpu32bug";
	163	cpu32bug_ops.to_longname = "CPU32Bug monitor";
	164	cpu32bug_ops.to_doc = "Debug via the CPU32Bug monitor.\n\
	165	Specify the serial device it is connected to (e.g. /dev/ttya).";
	166	cpu32bug_ops.to_open = cpu32bug_open;
	167
	168	add_target (&cpu32bug_ops);
	169	}