gdb/ppcbug-rom.c

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