[binutils.git] / gdb / ppcbug-rom.c

/* Remote debugging interface for PPCbug (PowerPC) 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 ppcbug_open PARAMS ((char *args, int from_tty));

static void
ppcbug_supply_register (regname, regnamelen, val, vallen)
     char *regname;
     int regnamelen;
     char *val;
     int vallen;
{
  int regno = 0, base = 0;

  if (regnamelen < 2 || regnamelen > 4)
    return;

  switch (regname[0])
    {
    case 'R':
      if (regname[1] < '0' || regname[1] > '9')
	return;
      if (regnamelen == 2)
	regno = regname[1] - '0';
      else if (regnamelen == 3 && regname[2] >= '0' && regname[2] <= '9')
	regno = (regname[1] - '0') * 10 + (regname[2] - '0');
      else
	return;
      break;
    case 'F':
      if (regname[1] != 'R' || regname[2] < '0' || regname[2] > '9')
	return;
      if (regnamelen == 3)
	regno = 32 + regname[2] - '0';
      else if (regnamelen == 4 && regname[3] >= '0' && regname[3] <= '9')
	regno = 32 + (regname[2] - '0') * 10 + (regname[3] - '0');
      else
	return;
      break;
    case 'I':
      if (regnamelen != 2 || regname[1] != 'P')
	return;
      regno = 64;
      break;
    case 'M':
      if (regnamelen != 3 || regname[1] != 'S' || regname[2] != 'R')
	return;
      regno = 65;
      break;
    case 'C':
      if (regnamelen != 2 || regname[1] != 'R')
	return;
      regno = 66;
      break;
    case 'S':
      if (regnamelen != 4 || regname[1] != 'P' || regname[2] != 'R')
	return;
      else if (regname[3] == '8')
	regno = 67;
      else if (regname[3] == '9')
	regno = 68;
      else if (regname[3] == '1')
	regno = 69;
      else if (regname[3] == '0')
	regno = 70;
      else
	return;
      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 *ppcbug_regnames[NUM_REGS] =
{
  "r0",   "r1",   "r2",   "r3",   "r4",   "r5",   "r6",   "r7",
  "r8",   "r9",   "r10",  "r11",  "r12",  "r13",  "r14",  "r15",
  "r16",  "r17",  "r18",  "r19",  "r20",  "r21",  "r22",  "r23",
  "r24",  "r25",  "r26",  "r27",  "r28",  "r29",  "r30",  "r31",

  "fr0",  "fr1",  "fr2",  "fr3",  "fr4",  "fr5",  "fr6",  "fr7",
  "fr8",  "fr9",  "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
  "fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
  "fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31",

/* pc      ps      cnd     lr      cnt     xer     mq */
  "ip",   "msr",  "cr",   "spr8", "spr9", "spr1", "spr0"
};

/*
 * 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 ppcbug_ops0;
static struct target_ops ppcbug_ops1;

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

#define PPC_CMDS(LOAD_CMD, OPS)						\
{									\
  MO_CLR_BREAK_USES_ADDR | MO_HANDLE_NL,				\
  ppcbug_inits,			/* Init strings */			\
  "g\r",			/* continue command */			\
  "t\r",			/* single step */			\
  NULL,				/* interrupt command */			\
  "br %x\r",			/* set a breakpoint */			\
  "nobr %x\r",			/* clear a breakpoint */		\
  "nobr\r",			/* clear all breakpoints */		\
  "bf %x:%x %x;b\r",		/* fill (start count val) */		\
  {									\
    "ms %x %02x\r",		/* setmem.cmdb (addr, value) */		\
    "ms %x %04x\r",		/* setmem.cmdw (addr, value) */		\
    "ms %x %08x\r",		/* setmem.cmdl (addr, value) */		\
    NULL,			/* setmem.cmdll (addr, value) */	\
    NULL,			/* setreg.resp_delim */			\
    NULL,			/* setreg.term */			\
    NULL,			/* setreg.term_cmd */			\
  },									\
  {									\
    "md %x:%x;b\r",		/* getmem.cmdb (addr, len) */		\
    "md %x:%x;b\r",		/* getmem.cmdw (addr, len) */		\
    "md %x:%x;b\r",		/* getmem.cmdl (addr, len) */		\
    NULL,			/* getmem.cmdll (addr, len) */		\
    " ",			/* getmem.resp_delim */			\
    NULL,			/* getmem.term */			\
    NULL,			/* getmem.term_cmd */			\
  },									\
  {									\
    "rs %s %x\r",		/* setreg.cmd (name, value) */		\
    NULL,			/* setreg.resp_delim */			\
    NULL,			/* setreg.term */			\
    NULL			/* setreg.term_cmd */			\
  },									\
  {									\
    "rs %s\r",			/* getreg.cmd (name) */			\
    "=",			/* getreg.resp_delim */			\
    NULL,			/* getreg.term */			\
    NULL			/* getreg.term_cmd */			\
  },									\
  "rd\r",			/* dump_registers */			\
  "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)", /* register_pattern */		\
  ppcbug_supply_register,	/* supply_register */			\
  NULL,				/* load_routine (defaults to SRECs) */	\
  LOAD_CMD,			/* download command */			\
  NULL,				/* load response */			\
  "PPC1-Bug>",			/* monitor command prompt */		\
  "\r",				/* end-of-line terminator */		\
  NULL,				/* optional command terminator */	\
  &OPS,				/* target operations */			\
  SERIAL_1_STOPBITS,		/* number of stop bits */		\
  ppcbug_regnames,		/* registers names */			\
  MONITOR_OPS_MAGIC		/* magic */				\
}


static struct monitor_ops ppcbug_cmds0 = PPC_CMDS("lo 0\r", ppcbug_ops0);
static struct monitor_ops ppcbug_cmds1 = PPC_CMDS("lo 1\r", ppcbug_ops1);

static void
ppcbug_open0(args, from_tty)
     char *args;
     int from_tty;
{
  monitor_open (args, &ppcbug_cmds0, from_tty);
}

static void
ppcbug_open1(args, from_tty)
     char *args;
     int from_tty;
{
  monitor_open (args, &ppcbug_cmds1, from_tty);
}

void
_initialize_ppcbug_rom ()
{
  init_monitor_ops (&ppcbug_ops0);

  ppcbug_ops0.to_shortname = "ppcbug";
  ppcbug_ops0.to_longname = "PowerPC PPCBug monitor on port 0";
  ppcbug_ops0.to_doc = "Debug via the PowerPC PPCBug monitor using port 0.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  ppcbug_ops0.to_open = ppcbug_open0;

  add_target (&ppcbug_ops0);

  init_monitor_ops (&ppcbug_ops1);

  ppcbug_ops1.to_shortname = "ppcbug1";
  ppcbug_ops1.to_longname = "PowerPC PPCBug monitor on port 1";
  ppcbug_ops1.to_doc = "Debug via the PowerPC PPCBug monitor using port 1.\n\
Specify the serial device it is connected to (e.g. /dev/ttya).";
  ppcbug_ops1.to_open = ppcbug_open1;

  add_target (&ppcbug_ops1);
}
Commit	Line	Data
cc7ef3c3 MM	1	/* Remote debugging interface for PPCbug (PowerPC) Rom monitor
	2	for GDB, the GNU debugger.
	3	Copyright 1995 Free Software Foundation, Inc.
	4
	5	Written by Stu Grossman of Cygnus Support
	6
	7	This file is part of GDB.
	8
	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.
	13
	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.
	18
	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, Boston, MA 02111-1307, USA. */
	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 ppcbug_open PARAMS ((char *args, int from_tty));
	30
	31	static void
	32	ppcbug_supply_register (regname, regnamelen, val, vallen)
	33	char *regname;
	34	int regnamelen;
	35	char *val;
	36	int vallen;
	37	{
	38	int regno = 0, base = 0;
	39
	40	if (regnamelen < 2 \|\| regnamelen > 4)
	41	return;
	42
cc7ef3c3 MM	43	switch (regname[0])
	44	{
	45	case 'R':
	46	if (regname[1] < '0' \|\| regname[1] > '9')
	47	return;
	48	if (regnamelen == 2)
	49	regno = regname[1] - '0';
	50	else if (regnamelen == 3 && regname[2] >= '0' && regname[2] <= '9')
	51	regno = (regname[1] - '0') * 10 + (regname[2] - '0');
	52	else
	53	return;
	54	break;
	55	case 'F':
	56	if (regname[1] != 'R' \|\| regname[2] < '0' \|\| regname[2] > '9')
	57	return;
	58	if (regnamelen == 3)
	59	regno = 32 + regname[2] - '0';
	60	else if (regnamelen == 4 && regname[3] >= '0' && regname[3] <= '9')
	61	regno = 32 + (regname[2] - '0') * 10 + (regname[3] - '0');
	62	else
	63	return;
	64	break;
	65	case 'I':
	66	if (regnamelen != 2 \|\| regname[1] != 'P')
	67	return;
	68	regno = 64;
	69	break;
	70	case 'M':
	71	if (regnamelen != 3 \|\| regname[1] != 'S' \|\| regname[2] != 'R')
	72	return;
	73	regno = 65;
	74	break;
	75	case 'C':
	76	if (regnamelen != 2 \|\| regname[1] != 'R')
	77	return;
	78	regno = 66;
	79	break;
	80	case 'S':
	81	if (regnamelen != 4 \|\| regname[1] != 'P' \|\| regname[2] != 'R')
	82	return;
	83	else if (regname[3] == '8')
	84	regno = 67;
	85	else if (regname[3] == '9')
	86	regno = 68;
	87	else if (regname[3] == '1')
	88	regno = 69;
	89	else if (regname[3] == '0')
	90	regno = 70;
	91	else
	92	return;
	93	break;
	94	default:
	95	return;
	96	}
	97
	98	monitor_supply_register (regno, val);
	99	}
	100
	101	/*
	102	* This array of registers needs to match the indexes used by GDB. The
	103	* whole reason this exists is because the various ROM monitors use
	104	* different names than GDB does, and don't support all the
	105	* registers either. So, typing "info reg sp" becomes an "A7".
	106	*/
107
108	static char *ppcbug_regnames[NUM_REGS] =
109	{
110	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
111	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
112	"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
113	"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
114
115	"fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
116	"fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
117	"fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
118	"fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31",
119
120	/* pc ps cnd lr cnt xer mq */
121	"ip", "msr", "cr", "spr8", "spr9", "spr1", "spr0"
122	};
123
124	/*
125	* Define the monitor command strings. Since these are passed directly
126	* through to a printf style function, we need can include formatting
127	* strings. We also need a CR or LF on the end.
128	*/
129
721ccd80 MM	130	static struct target_ops ppcbug_ops0;
721ccd80 MM	131	static struct target_ops ppcbug_ops1;
cc7ef3c3 MM	132
	133	static char *ppcbug_inits[] = {"\r", NULL};
	134
721ccd80 MM	135	#define PPC_CMDS(LOAD_CMD, OPS) \
	136	{ \
	137	MO_CLR_BREAK_USES_ADDR \| MO_HANDLE_NL, \
	138	ppcbug_inits, /* Init strings */ \
	139	"g\r", /* continue command */ \
	140	"t\r", /* single step */ \
	141	NULL, /* interrupt command */ \
	142	"br %x\r", /* set a breakpoint */ \
	143	"nobr %x\r", /* clear a breakpoint */ \
	144	"nobr\r", /* clear all breakpoints */ \
	145	"bf %x:%x %x;b\r", /* fill (start count val) */ \
	146	{ \
	147	"ms %x %02x\r", /* setmem.cmdb (addr, value) */ \
	148	"ms %x %04x\r", /* setmem.cmdw (addr, value) */ \
	149	"ms %x %08x\r", /* setmem.cmdl (addr, value) */ \
	150	NULL, /* setmem.cmdll (addr, value) */ \
	151	NULL, /* setreg.resp_delim */ \
	152	NULL, /* setreg.term */ \
	153	NULL, /* setreg.term_cmd */ \
	154	}, \
	155	{ \
	156	"md %x:%x;b\r", /* getmem.cmdb (addr, len) */ \
	157	"md %x:%x;b\r", /* getmem.cmdw (addr, len) */ \
	158	"md %x:%x;b\r", /* getmem.cmdl (addr, len) */ \
	159	NULL, /* getmem.cmdll (addr, len) */ \
	160	" ", /* getmem.resp_delim */ \
	161	NULL, /* getmem.term */ \
	162	NULL, /* getmem.term_cmd */ \
	163	}, \
	164	{ \
	165	"rs %s %x\r", /* setreg.cmd (name, value) */ \
	166	NULL, /* setreg.resp_delim */ \
	167	NULL, /* setreg.term */ \
	168	NULL /* setreg.term_cmd */ \
	169	}, \
	170	{ \
	171	"rs %s\r", /* getreg.cmd (name) */ \
	172	"=", /* getreg.resp_delim */ \
	173	NULL, /* getreg.term */ \
	174	NULL /* getreg.term_cmd */ \
	175	}, \
	176	"rd\r", /* dump_registers */ \
	177	"\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)", /* register_pattern */ \
	178	ppcbug_supply_register, /* supply_register */ \
	179	NULL, /* load_routine (defaults to SRECs) */ \
	180	LOAD_CMD, /* download command */ \
	181	NULL, /* load response */ \
	182	"PPC1-Bug>", /* monitor command prompt */ \
	183	"\r", /* end-of-line terminator */ \
	184	NULL, /* optional command terminator */ \
	185	&OPS, /* target operations */ \
	186	SERIAL_1_STOPBITS, /* number of stop bits */ \
	187	ppcbug_regnames, /* registers names */ \
	188	MONITOR_OPS_MAGIC /* magic */ \
	189	}
	190
	191
	192	static struct monitor_ops ppcbug_cmds0 = PPC_CMDS("lo 0\r", ppcbug_ops0);
	193	static struct monitor_ops ppcbug_cmds1 = PPC_CMDS("lo 1\r", ppcbug_ops1);
	194
	195	static void
	196	ppcbug_open0(args, from_tty)
	197	char *args;
	198	int from_tty;
cc7ef3c3	199	{
721ccd80 MM	200	monitor_open (args, &ppcbug_cmds0, from_tty);
721ccd80 MM	201	}
cc7ef3c3 MM	202
cc7ef3c3 MM	203	static void
721ccd80	204	ppcbug_open1(args, from_tty)
cc7ef3c3 MM	205	char *args;
	206	int from_tty;
	207	{
721ccd80	208	monitor_open (args, &ppcbug_cmds1, from_tty);
cc7ef3c3 MM	209	}
	210
	211	void
	212	_initialize_ppcbug_rom ()
	213	{
721ccd80 MM	214	init_monitor_ops (&ppcbug_ops0);
	215
	216	ppcbug_ops0.to_shortname = "ppcbug";
	217	ppcbug_ops0.to_longname = "PowerPC PPCBug monitor on port 0";
	218	ppcbug_ops0.to_doc = "Debug via the PowerPC PPCBug monitor using port 0.\n\
	219	Specify the serial device it is connected to (e.g. /dev/ttya).";
	220	ppcbug_ops0.to_open = ppcbug_open0;
	221
	222	add_target (&ppcbug_ops0);
	223
	224	init_monitor_ops (&ppcbug_ops1);
cc7ef3c3	225
721ccd80 MM	226	ppcbug_ops1.to_shortname = "ppcbug1";
	227	ppcbug_ops1.to_longname = "PowerPC PPCBug monitor on port 1";
	228	ppcbug_ops1.to_doc = "Debug via the PowerPC PPCBug monitor using port 1.\n\
cc7ef3c3	229	Specify the serial device it is connected to (e.g. /dev/ttya).";
721ccd80	230	ppcbug_ops1.to_open = ppcbug_open1;
cc7ef3c3	231
721ccd80	232	add_target (&ppcbug_ops1);
cc7ef3c3	233	}