gdb/ppcbug-rom.c

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