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

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