[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
   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., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

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

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