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