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_ops;
 131
 132 static char *ppcbug_inits[] = {"\r", NULL};
 133
 134 static struct monitor_ops ppcbug_cmds =
 135 {
 136                                 /* use read single because PPCBUG insists on emiting
 137                                    the word in character notation after the hex.  */
 138   MO_CLR_BREAK_USES_ADDR | MO_GETMEM_READ_SINGLE,
 139   ppcbug_inits,                 /* Init strings */
 140   "g\r",                        /* continue command */
 141   "t\r",                        /* single step */
 142   NULL,                         /* interrupt command */
 143   "br %x\r",                    /* set a breakpoint */
 144   "nobr %x\r",                  /* clear a breakpoint */
 145   "nobr\r",                     /* clear all breakpoints */
 146   "bf %x:%x %x;b\r",            /* fill (start count val) */
 147   {
 148     "ms %x %02x\r",             /* setmem.cmdb (addr, value) */
 149     "ms %x %04x\r",             /* setmem.cmdw (addr, value) */
 150     "ms %x %08x\r",             /* setmem.cmdl (addr, value) */
 151     NULL,                       /* setmem.cmdll (addr, value) */
 152     NULL,                       /* setreg.resp_delim */
 153     NULL,                       /* setreg.term */
 154     NULL,                       /* setreg.term_cmd */
 155   },
 156   {
 157     "md %x;b\r",                /* getmem.cmdb addr */
 158     "md %x;h\r",                /* getmem.cmdw addr */
 159     "md %x;w\r",                /* getmem.cmdl addr */
 160     "md %x:2;w\r",              /* getmem.cmdll addr */
 161     " ",                        /* getmem.resp_delim */
 162     NULL,                       /* getmem.term */
 163     NULL,                       /* getmem.term_cmd */
 164   },
 165   {
 166     "rs %s %x\r",               /* setreg.cmd (name, value) */
 167     NULL,                       /* setreg.resp_delim */
 168     NULL,                       /* setreg.term */
 169     NULL                        /* setreg.term_cmd */
 170   },
 171   {
 172     "rs %s\r",                  /* getreg.cmd (name) */
 173     "=",                        /* getreg.resp_delim */
 174     NULL,                       /* getreg.term */
 175     NULL                        /* getreg.term_cmd */
 176   },
 177   "rd\r",                       /* dump_registers */
 178   "\\(\\w+\\) +=\\([0-9a-fA-F]+\\b\\)", /* register_pattern */
 179   ppcbug_supply_register,       /* supply_register */
 180   NULL,                         /* load_routine (defaults to SRECs) */
 181   "lo 0\r",                     /* download command */
 182   NULL,                         /* load response */
 183   "PPC1-Bug>",                  /* monitor command prompt */
 184   "\r",                         /* end-of-line terminator */
 185   NULL,                         /* optional command terminator */
 186   &ppcbug_ops,                  /* target operations */
 187   SERIAL_1_STOPBITS,            /* number of stop bits */
 188   ppcbug_regnames,              /* registers names */
 189   MONITOR_OPS_MAGIC             /* magic */
 190   };
 191
 192 static void
 193 ppcbug_open(args, from_tty)
 194      char *args;
 195      int from_tty;
 196 {
 197   monitor_open (args, &ppcbug_cmds, from_tty);
 198 }
 199
 200 void
 201 _initialize_ppcbug_rom ()
 202 {
 203   init_monitor_ops (&ppcbug_ops);
 204
 205   ppcbug_ops.to_shortname = "ppcbug";
 206   ppcbug_ops.to_longname = "PowerPC PPCBug monitor";
 207   ppcbug_ops.to_doc = "Debug via the PowerPC PPCBug monitor.\n\
 208 Specify the serial device it is connected to (e.g. /dev/ttya).";
 209   ppcbug_ops.to_open = ppcbug_open;
 210
 211   add_target (&ppcbug_ops);
 212 }