[thirdparty/binutils-gdb.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};

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