OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [ppcbug-rom.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.