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