gdb/dbug-rom.c

   1 /* Remote debugging interface to dBUG ROM monitor for GDB, the GNU debugger.
   2    Copyright (C) 1996, 1998, 1999, 2000, 2001, 2007, 2008
   3    Free Software Foundation, Inc.
   4
   5    Written by Stan Shebs 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 /* dBUG is a monitor supplied on various Motorola boards, including
  23    m68k, ColdFire, and PowerPC-based designs.  The code here assumes
  24    the ColdFire, and (as of 9/25/96) has only been tested with a
  25    ColdFire IDP board.  */
  26
  27 #include "defs.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "monitor.h"
  31 #include "serial.h"
  32 #include "regcache.h"
  33
  34 #include "m68k-tdep.h"
  35
  36 static void dbug_open (char *args, int from_tty);
  37
  38 static void
  39 dbug_supply_register (struct regcache *regcache, char *regname,
  40                       int regnamelen, char *val, int vallen)
  41 {
  42   int regno;
  43   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  44
  45   if (regnamelen != 2)
  46     return;
  47
  48   switch (regname[0])
  49     {
  50     case 'S':
  51       if (regname[1] != 'R')
  52         return;
  53       regno = gdbarch_ps_regnum (gdbarch);
  54       break;
  55     case 'P':
  56       if (regname[1] != 'C')
  57         return;
  58       regno = gdbarch_pc_regnum (gdbarch);
  59       break;
  60     case 'D':
  61       if (regname[1] < '0' || regname[1] > '7')
  62         return;
  63       regno = regname[1] - '0' + M68K_D0_REGNUM;
  64       break;
  65     case 'A':
  66       if (regname[1] < '0' || regname[1] > '7')
  67         return;
  68       regno = regname[1] - '0' + M68K_A0_REGNUM;
  69       break;
  70     default:
  71       return;
  72     }
  73
  74   monitor_supply_register (regcache, regno, val);
  75 }
  76
  77 /* This array of registers needs to match the indexes used by GDB. The
  78    whole reason this exists is because the various ROM monitors use
  79    different names than GDB does, and don't support all the registers
  80    either. So, typing "info reg sp" becomes an "A7". */
  81
  82 static const char *
  83 dbug_regname (int index)
  84 {
  85   static char *regnames[] =
  86   {
  87     "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
  88     "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
  89     "SR", "PC"
  90     /* no float registers */
  91   };
  92
  93   if ((index >= (sizeof (regnames) / sizeof (regnames[0])))
  94       || (index < 0) || (index >= gdbarch_num_regs (current_gdbarch)))
  95     return NULL;
  96   else
  97     return regnames[index];
  98
  99 }
 100
 101 static struct target_ops dbug_ops;
 102 static struct monitor_ops dbug_cmds;
 103
 104 static char *dbug_inits[] =
 105 {"\r", NULL};
 106
 107
 108 static void
 109 init_dbug_cmds (void)
 110 {
 111   dbug_cmds.flags = MO_CLR_BREAK_USES_ADDR | MO_GETMEM_NEEDS_RANGE | MO_FILL_USES_ADDR;
 112   dbug_cmds.init = dbug_inits;  /* Init strings */
 113   dbug_cmds.cont = "go\r";      /* continue command */
 114   dbug_cmds.step = "trace\r";   /* single step */
 115   dbug_cmds.stop = NULL;        /* interrupt command */
 116   dbug_cmds.set_break = "br %x\r";      /* set a breakpoint */
 117   dbug_cmds.clr_break = "br -r %x\r";   /* clear a breakpoint */
 118   dbug_cmds.clr_all_break = "br -r\r";  /* clear all breakpoints */
 119   dbug_cmds.fill = "bf.b %x %x %x\r";   /* fill (start end val) */
 120   dbug_cmds.setmem.cmdb = "mm.b %x %x\r";       /* setmem.cmdb (addr, value) */
 121   dbug_cmds.setmem.cmdw = "mm.w %x %x\r";       /* setmem.cmdw (addr, value) */
 122   dbug_cmds.setmem.cmdl = "mm.l %x %x\r";       /* setmem.cmdl (addr, value) */
 123   dbug_cmds.setmem.cmdll = NULL;        /* setmem.cmdll (addr, value) */
 124   dbug_cmds.setmem.resp_delim = NULL;   /* setmem.resp_delim */
 125   dbug_cmds.setmem.term = NULL; /* setmem.term */
 126   dbug_cmds.setmem.term_cmd = NULL;     /* setmem.term_cmd */
 127   dbug_cmds.getmem.cmdb = "md.b %x %x\r";       /* getmem.cmdb (addr, addr2) */
 128   dbug_cmds.getmem.cmdw = "md.w %x %x\r";       /* getmem.cmdw (addr, addr2) */
 129   dbug_cmds.getmem.cmdl = "md.l %x %x\r";       /* getmem.cmdl (addr, addr2) */
 130   dbug_cmds.getmem.cmdll = NULL;        /* getmem.cmdll (addr, addr2) */
 131   dbug_cmds.getmem.resp_delim = ":";    /* getmem.resp_delim */
 132   dbug_cmds.getmem.term = NULL; /* getmem.term */
 133   dbug_cmds.getmem.term_cmd = NULL;     /* getmem.term_cmd */
 134   dbug_cmds.setreg.cmd = "rm %s %x\r";  /* setreg.cmd (name, value) */
 135   dbug_cmds.setreg.resp_delim = NULL;   /* setreg.resp_delim */
 136   dbug_cmds.setreg.term = NULL; /* setreg.term */
 137   dbug_cmds.setreg.term_cmd = NULL;     /* setreg.term_cmd */
 138   dbug_cmds.getreg.cmd = "rd %s\r";     /* getreg.cmd (name) */
 139   dbug_cmds.getreg.resp_delim = ":";    /* getreg.resp_delim */
 140   dbug_cmds.getreg.term = NULL; /* getreg.term */
 141   dbug_cmds.getreg.term_cmd = NULL;     /* getreg.term_cmd */
 142   dbug_cmds.dump_registers = "rd\r";    /* dump_registers */
 143   dbug_cmds.register_pattern = "\\(\\w+\\) +:\\([0-9a-fA-F]+\\b\\)";    /* register_pattern */
 144   dbug_cmds.supply_register = dbug_supply_register;
 145   dbug_cmds.load_routine = NULL;        /* load_routine (defaults to SRECs) */
 146   dbug_cmds.load = "dl\r";      /* download command */
 147   dbug_cmds.loadresp = "\n";    /* load response */
 148   dbug_cmds.prompt = "dBUG>";   /* monitor command prompt */
 149   dbug_cmds.line_term = "\r";   /* end-of-line terminator */
 150   dbug_cmds.cmd_end = NULL;     /* optional command terminator */
 151   dbug_cmds.target = &dbug_ops; /* target operations */
 152   dbug_cmds.stopbits = SERIAL_1_STOPBITS;       /* number of stop bits */
 153   dbug_cmds.regnames = NULL;    /* registers names */
 154   dbug_cmds.regname = dbug_regname;
 155   dbug_cmds.magic = MONITOR_OPS_MAGIC;  /* magic */
 156 }                               /* init_debug_ops */
 157
 158 static void
 159 dbug_open (char *args, int from_tty)
 160 {
 161   monitor_open (args, &dbug_cmds, from_tty);
 162 }
 163
 164 extern initialize_file_ftype _initialize_dbug_rom; /* -Wmissing-prototypes */
 165
 166 void
 167 _initialize_dbug_rom (void)
 168 {
 169   init_dbug_cmds ();
 170   init_monitor_ops (&dbug_ops);
 171
 172   dbug_ops.to_shortname = "dbug";
 173   dbug_ops.to_longname = "dBUG monitor";
 174   dbug_ops.to_doc = "Debug via the dBUG monitor.\n\
 175 Specify the serial device it is connected to (e.g. /dev/ttya).";
 176   dbug_ops.to_open = dbug_open;
 177
 178   add_target (&dbug_ops);
 179 }