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 static void
 136 init_ppc_cmds (char  * LOAD_CMD,
 137                struct monitor_ops * OPS,
 138                struct target_ops * targops)
 139 {
 140   OPS->flags = MO_CLR_BREAK_USES_ADDR | MO_HANDLE_NL;
 141   OPS->init = ppcbug_inits;             /* Init strings */
 142   OPS->cont = "g\r";                    /* continue command */
 143   OPS->step = "t\r";                    /* single step */
 144   OPS->stop = NULL;                     /* interrupt command */
 145   OPS->set_break = "br %x\r";           /* set a breakpoint */
 146   OPS->clr_break = "nobr %x\r";         /* clear a breakpoint */
 147   OPS->clr_all_break = "nobr\r";        /* clear all breakpoints */
 148   OPS->fill = "bf %x:%x %x;b\r";        /* fill (start count val) */
 149   OPS->setmem.cmdb = "ms %x %02x\r";    /* setmem.cmdb (addr, value) */
 150   OPS->setmem.cmdw = "ms %x %04x\r";    /* setmem.cmdw (addr, value) */
 151   OPS->setmem.cmdl = "ms %x %08x\r";    /* setmem.cmdl (addr, value) */
 152   OPS->setmem.cmdll = NULL;             /* setmem.cmdll (addr, value) */
 153   OPS->setmem.resp_delim = NULL;        /* setreg.resp_delim */
 154   OPS->setmem.term = NULL;              /* setreg.term */
 155   OPS->setmem.term_cmd = NULL;          /* setreg.term_cmd */
 156   OPS->getmem.cmdb = "md %x:%x;b\r";    /* getmem.cmdb (addr, len) */
 157   OPS->getmem.cmdw = "md %x:%x;b\r";    /* getmem.cmdw (addr, len) */
 158   OPS->getmem.cmdl = "md %x:%x;b\r";    /* getmem.cmdl (addr, len) */
 159   OPS->getmem.cmdll = NULL;             /* getmem.cmdll (addr, len) */
 160   OPS->getmem.resp_delim = " ";         /* getmem.resp_delim */
 161   OPS->getmem.term = NULL;              /* getmem.term */
 162   OPS->getmem.term_cmd = NULL;          /* getmem.term_cmd */
 163   OPS->setreg.cmd = "rs %s %x\r";       /* setreg.cmd (name, value) */
 164   OPS->setreg.resp_delim = NULL;        /* setreg.resp_delim */
 165   OPS->setreg.term = NULL;              /* setreg.term */
 166   OPS->setreg.term_cmd = NULL   ;       /* setreg.term_cmd */
 167   OPS->getreg.cmd = "rs %s\r";          /* getreg.cmd (name) */
 168   OPS->getreg.resp_delim = "=";         /* getreg.resp_delim */
 169   OPS->getreg.term = NULL;              /* getreg.term */
 170   OPS->getreg.term_cmd = NULL   ;       /* getreg.term_cmd */
 171   OPS->register_pattern = "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)"; /* register_pattern */
 172   OPS->supply_register = ppcbug_supply_register;        /* supply_register */
 173   OPS->dump_registers = "rd\r";         /* dump all registers */
 174   OPS->load_routine = NULL;             /* load_routine (defaults to SRECs) */
 175   OPS->load = LOAD_CMD;                 /* download command */
 176   OPS->loadresp = NULL;                 /* load response */
 177   OPS->prompt = "PPC1-Bug>";            /* monitor command prompt */
 178   OPS->line_term = "\r";                /* end-of-line terminator */
 179   OPS->cmd_end = NULL;                  /* optional command terminator */
 180   OPS->target = targops ;               /* target operations */
 181   OPS->stopbits = SERIAL_1_STOPBITS;    /* number of stop bits */
 182   OPS->regnames = ppcbug_regnames;      /* registers names */
 183   OPS->magic = MONITOR_OPS_MAGIC;       /* magic */
 184 }
 185
 186
 187 static struct monitor_ops ppcbug_cmds0 ;
 188 static struct monitor_ops ppcbug_cmds1 ;
 189
 190 static void
 191 ppcbug_open0(args, from_tty)
 192      char *args;
 193      int from_tty;
 194 {
 195   monitor_open (args, &ppcbug_cmds0, from_tty);
 196 }
 197
 198 static void
 199 ppcbug_open1(args, from_tty)
 200      char *args;
 201      int from_tty;
 202 {
 203   monitor_open (args, &ppcbug_cmds1, from_tty);
 204 }
 205
 206 void
 207 _initialize_ppcbug_rom ()
 208 {
 209   init_ppc_cmds("lo 0\r", &ppcbug_cmds0, &ppcbug_ops0) ;
 210   init_ppc_cmds("lo 1\r", &ppcbug_cmds1, &ppcbug_ops1);
 211   init_monitor_ops (&ppcbug_ops0);
 212
 213   ppcbug_ops0.to_shortname = "ppcbug";
 214   ppcbug_ops0.to_longname = "PowerPC PPCBug monitor on port 0";
 215   ppcbug_ops0.to_doc = "Debug via the PowerPC PPCBug monitor using port 0.\n\
 216 Specify the serial device it is connected to (e.g. /dev/ttya).";
 217   ppcbug_ops0.to_open = ppcbug_open0;
 218
 219   add_target (&ppcbug_ops0);
 220
 221   init_monitor_ops (&ppcbug_ops1);
 222
 223   ppcbug_ops1.to_shortname = "ppcbug1";
 224   ppcbug_ops1.to_longname = "PowerPC PPCBug monitor on port 1";
 225   ppcbug_ops1.to_doc = "Debug via the PowerPC PPCBug monitor using port 1.\n\
 226 Specify the serial device it is connected to (e.g. /dev/ttya).";
 227   ppcbug_ops1.to_open = ppcbug_open1;
 228
 229   add_target (&ppcbug_ops1);
 230 }