gdb/ppcbug-rom.c

   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
   7    This file is part of GDB.
   8
   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.
  13
  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.
  18
  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.  */
  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 {
 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",
 115
 116   "fr0", "fr1", "fr2", "fr3", "fr4", "fr5", "fr6", "fr7",
 117   "fr8", "fr9", "fr10", "fr11", "fr12", "fr13", "fr14", "fr15",
 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 */
 122   "ip", "msr", "cr", "spr8", "spr9", "spr1", "spr0"
 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
 134 static char *ppcbug_inits[] =
 135 {"\r", NULL};
 136
 137 static void
 138 init_ppc_cmds (char *LOAD_CMD,
 139                struct monitor_ops *OPS,
 140                struct target_ops *targops)
 141 {
 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 */
 149   OPS->clr_all_break = "nobr\r";        /* clear all breakpoints */
 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 */
 186 }
 187
 188
 189 static struct monitor_ops ppcbug_cmds0;
 190 static struct monitor_ops ppcbug_cmds1;
 191
 192 static void
 193 ppcbug_open0 (args, from_tty)
 194      char *args;
 195      int from_tty;
 196 {
 197   monitor_open (args, &ppcbug_cmds0, from_tty);
 198 }
 199
 200 static void
 201 ppcbug_open1 (args, from_tty)
 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 {
 211   init_ppc_cmds ("lo 0\r", &ppcbug_cmds0, &ppcbug_ops0);
 212   init_ppc_cmds ("lo 1\r", &ppcbug_cmds1, &ppcbug_ops1);
 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 }