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