]>
Commit | Line | Data |
---|---|---|
cc7ef3c3 MM |
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 | ||
cc7ef3c3 MM |
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 | { | |
98a2c9d2 MM |
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, | |
cc7ef3c3 MM |
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 | { | |
98a2c9d2 MM |
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 */ | |
cc7ef3c3 MM |
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 | } |