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

/* Remote debugging interface for PPCbug (PowerPC) Rom monitor
   for GDB, the GNU debugger.
   Copyright (C) 1995, 1998, 1999, 2000, 2001, 2007, 2008
   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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "gdbcore.h"
#include "target.h"
#include "monitor.h"
#include "serial.h"
#include "regcache.h"

static void
ppcbug_supply_register (struct regcache *regcache, char *regname,
			int regnamelen, char *val, int vallen)
{
  int regno = 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 (regcache, 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[] =
{
  "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};

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


static struct monitor_ops ppcbug_cmds0;
static struct monitor_ops ppcbug_cmds1;

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

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

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

void
_initialize_ppcbug_rom (void)
{
  init_ppc_cmds ("lo 0\r", &ppcbug_cmds0, &ppcbug_ops0);
  init_ppc_cmds ("lo 1\r", &ppcbug_cmds1, &ppcbug_ops1);
  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
c906108c SS	1	/* Remote debugging interface for PPCbug (PowerPC) Rom monitor
c906108c SS	2	for GDB, the GNU debugger.
9b254dd1	3	Copyright (C) 1995, 1998, 1999, 2000, 2001, 2007, 2008
6aba47ca	4	Free Software Foundation, Inc.
c906108c SS	5
	6	Written by Stu Grossman of Cygnus Support
	7
c5aa993b	8	This file is part of GDB.
c906108c	9
c5aa993b JM	10	This program is free software; you can redistribute it and/or modify
c5aa993b JM	11	it under the terms of the GNU General Public License as published by
a9762ec7	12	the Free Software Foundation; either version 3 of the License, or
c5aa993b	13	(at your option) any later version.
c906108c	14
c5aa993b JM	15	This program is distributed in the hope that it will be useful,
	16	but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	GNU General Public License for more details.
c906108c	19
c5aa993b	20	You should have received a copy of the GNU General Public License
a9762ec7	21	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	22
	23	#include "defs.h"
	24	#include "gdbcore.h"
	25	#include "target.h"
	26	#include "monitor.h"
	27	#include "serial.h"
4e052eda	28	#include "regcache.h"
c906108c	29
c906108c	30	static void
c410a84c UW	31	ppcbug_supply_register (struct regcache regcache, char regname,
c410a84c UW	32	int regnamelen, char *val, int vallen)
c906108c	33	{
d4f3574e	34	int regno = 0;
c906108c SS	35
	36	if (regnamelen < 2 \|\| regnamelen > 4)
	37	return;
	38
	39	switch (regname[0])
	40	{
	41	case 'R':
	42	if (regname[1] < '0' \|\| regname[1] > '9')
	43	return;
	44	if (regnamelen == 2)
	45	regno = regname[1] - '0';
	46	else if (regnamelen == 3 && regname[2] >= '0' && regname[2] <= '9')
	47	regno = (regname[1] - '0') * 10 + (regname[2] - '0');
	48	else
	49	return;
	50	break;
	51	case 'F':
	52	if (regname[1] != 'R' \|\| regname[2] < '0' \|\| regname[2] > '9')
	53	return;
	54	if (regnamelen == 3)
	55	regno = 32 + regname[2] - '0';
	56	else if (regnamelen == 4 && regname[3] >= '0' && regname[3] <= '9')
	57	regno = 32 + (regname[2] - '0') * 10 + (regname[3] - '0');
	58	else
	59	return;
	60	break;
	61	case 'I':
	62	if (regnamelen != 2 \|\| regname[1] != 'P')
	63	return;
	64	regno = 64;
	65	break;
	66	case 'M':
	67	if (regnamelen != 3 \|\| regname[1] != 'S' \|\| regname[2] != 'R')
	68	return;
	69	regno = 65;
	70	break;
	71	case 'C':
	72	if (regnamelen != 2 \|\| regname[1] != 'R')
	73	return;
	74	regno = 66;
	75	break;
	76	case 'S':
	77	if (regnamelen != 4 \|\| regname[1] != 'P' \|\| regname[2] != 'R')
	78	return;
	79	else if (regname[3] == '8')
	80	regno = 67;
	81	else if (regname[3] == '9')
	82	regno = 68;
	83	else if (regname[3] == '1')
	84	regno = 69;
	85	else if (regname[3] == '0')
	86	regno = 70;
	87	else
	88	return;
	89	break;
	90	default:
	91	return;
	92	}
	93
c410a84c	94	monitor_supply_register (regcache, regno, val);
c906108c SS	95	}
	96
	97	/*
	98	* This array of registers needs to match the indexes used by GDB. The
	99	* whole reason this exists is because the various ROM monitors use
	100	* different names than GDB does, and don't support all the
	101	* registers either. So, typing "info reg sp" becomes an "A7".
	102	*/
	103
fe794dc6	104	static char *ppcbug_regnames[] =
c906108c	105	{
c5aa993b JM	106	"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
	107	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
	108	"r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
	109	"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
c906108c	110
c5aa993b JM	111	"fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
c5aa993b JM	112	"fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
c906108c SS	113	"fr16", "fr17", "fr18", "fr19", "fr20", "fr21", "fr22", "fr23",
	114	"fr24", "fr25", "fr26", "fr27", "fr28", "fr29", "fr30", "fr31",
	115
	116	/* pc ps cnd lr cnt xer mq */
c5aa993b	117	"ip", "msr", "cr", "spr8", "spr9", "spr1", "spr0"
c906108c SS	118	};
	119
	120	/*
	121	* Define the monitor command strings. Since these are passed directly
	122	* through to a printf style function, we need can include formatting
	123	* strings. We also need a CR or LF on the end.
	124	*/
	125
	126	static struct target_ops ppcbug_ops0;
	127	static struct target_ops ppcbug_ops1;
	128
c5aa993b JM	129	static char *ppcbug_inits[] =
c5aa993b JM	130	{"\r", NULL};
c906108c SS	131
c906108c SS	132	static void
c5aa993b JM	133	init_ppc_cmds (char *LOAD_CMD,
	134	struct monitor_ops *OPS,
	135	struct target_ops *targops)
c906108c	136	{
c5aa993b JM	137	OPS->flags = MO_CLR_BREAK_USES_ADDR \| MO_HANDLE_NL;
	138	OPS->init = ppcbug_inits; /* Init strings */
	139	OPS->cont = "g\r"; /* continue command */
	140	OPS->step = "t\r"; /* single step */
	141	OPS->stop = NULL; /* interrupt command */
	142	OPS->set_break = "br %x\r"; /* set a breakpoint */
	143	OPS->clr_break = "nobr %x\r"; /* clear a breakpoint */
c906108c	144	OPS->clr_all_break = "nobr\r"; /* clear all breakpoints */
c5aa993b JM	145	OPS->fill = "bf %x:%x %x;b\r"; /* fill (start count val) */
	146	OPS->setmem.cmdb = "ms %x %02x\r"; /* setmem.cmdb (addr, value) */
	147	OPS->setmem.cmdw = "ms %x %04x\r"; /* setmem.cmdw (addr, value) */
	148	OPS->setmem.cmdl = "ms %x %08x\r"; /* setmem.cmdl (addr, value) */
	149	OPS->setmem.cmdll = NULL; /* setmem.cmdll (addr, value) */
	150	OPS->setmem.resp_delim = NULL; /* setreg.resp_delim */
	151	OPS->setmem.term = NULL; /* setreg.term */
	152	OPS->setmem.term_cmd = NULL; /* setreg.term_cmd */
	153	OPS->getmem.cmdb = "md %x:%x;b\r"; /* getmem.cmdb (addr, len) */
	154	OPS->getmem.cmdw = "md %x:%x;b\r"; /* getmem.cmdw (addr, len) */
	155	OPS->getmem.cmdl = "md %x:%x;b\r"; /* getmem.cmdl (addr, len) */
	156	OPS->getmem.cmdll = NULL; /* getmem.cmdll (addr, len) */
	157	OPS->getmem.resp_delim = " "; /* getmem.resp_delim */
	158	OPS->getmem.term = NULL; /* getmem.term */
	159	OPS->getmem.term_cmd = NULL; /* getmem.term_cmd */
	160	OPS->setreg.cmd = "rs %s %x\r"; /* setreg.cmd (name, value) */
	161	OPS->setreg.resp_delim = NULL; /* setreg.resp_delim */
	162	OPS->setreg.term = NULL; /* setreg.term */
	163	OPS->setreg.term_cmd = NULL; /* setreg.term_cmd */
	164	OPS->getreg.cmd = "rs %s\r"; /* getreg.cmd (name) */
	165	OPS->getreg.resp_delim = "="; /* getreg.resp_delim */
	166	OPS->getreg.term = NULL; /* getreg.term */
	167	OPS->getreg.term_cmd = NULL; /* getreg.term_cmd */
	168	OPS->register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
23a6d369	169	OPS->supply_register = ppcbug_supply_register;
c5aa993b JM	170	OPS->dump_registers = "rd\r"; /* dump all registers */
	171	OPS->load_routine = NULL; /* load_routine (defaults to SRECs) */
	172	OPS->load = LOAD_CMD; /* download command */
	173	OPS->loadresp = NULL; /* load response */
	174	OPS->prompt = "PPC1-Bug>"; /* monitor command prompt */
	175	OPS->line_term = "\r"; /* end-of-line terminator */
	176	OPS->cmd_end = NULL; /* optional command terminator */
	177	OPS->target = targops; /* target operations */
	178	OPS->stopbits = SERIAL_1_STOPBITS; /* number of stop bits */
	179	OPS->regnames = ppcbug_regnames; /* registers names */
	180	OPS->magic = MONITOR_OPS_MAGIC; /* magic */
c906108c SS	181	}
	182
	183
c5aa993b JM	184	static struct monitor_ops ppcbug_cmds0;
c5aa993b JM	185	static struct monitor_ops ppcbug_cmds1;
c906108c SS	186
c906108c SS	187	static void
fba45db2	188	ppcbug_open0 (char *args, int from_tty)
c906108c SS	189	{
	190	monitor_open (args, &ppcbug_cmds0, from_tty);
	191	}
	192
	193	static void
fba45db2	194	ppcbug_open1 (char *args, int from_tty)
c906108c SS	195	{
	196	monitor_open (args, &ppcbug_cmds1, from_tty);
	197	}
	198
a78f21af AC	199	extern initialize_file_ftype _initialize_ppcbug_rom; /* -Wmissing-prototypes */
a78f21af AC	200
c906108c	201	void
fba45db2	202	_initialize_ppcbug_rom (void)
c906108c	203	{
c5aa993b JM	204	init_ppc_cmds ("lo 0\r", &ppcbug_cmds0, &ppcbug_ops0);
c5aa993b JM	205	init_ppc_cmds ("lo 1\r", &ppcbug_cmds1, &ppcbug_ops1);
c906108c SS	206	init_monitor_ops (&ppcbug_ops0);
	207
	208	ppcbug_ops0.to_shortname = "ppcbug";
	209	ppcbug_ops0.to_longname = "PowerPC PPCBug monitor on port 0";
	210	ppcbug_ops0.to_doc = "Debug via the PowerPC PPCBug monitor using port 0.\n\
	211	Specify the serial device it is connected to (e.g. /dev/ttya).";
	212	ppcbug_ops0.to_open = ppcbug_open0;
	213
	214	add_target (&ppcbug_ops0);
	215
	216	init_monitor_ops (&ppcbug_ops1);
	217
	218	ppcbug_ops1.to_shortname = "ppcbug1";
	219	ppcbug_ops1.to_longname = "PowerPC PPCBug monitor on port 1";
	220	ppcbug_ops1.to_doc = "Debug via the PowerPC PPCBug monitor using port 1.\n\
	221	Specify the serial device it is connected to (e.g. /dev/ttya).";
	222	ppcbug_ops1.to_open = ppcbug_open1;
	223
	224	add_target (&ppcbug_ops1);
	225	}