1 |
24 |
jeremybenn |
/* Remote debugging interface for boot monitors, for GDB.
|
2 |
|
|
|
3 |
|
|
Copyright (C) 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
|
4 |
|
|
2000, 2001, 2002, 2006, 2007, 2008 Free Software Foundation, Inc.
|
5 |
|
|
|
6 |
|
|
Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
|
7 |
|
|
Resurrected from the ashes by Stu Grossman.
|
8 |
|
|
|
9 |
|
|
This file is part of GDB.
|
10 |
|
|
|
11 |
|
|
This program is free software; you can redistribute it and/or modify
|
12 |
|
|
it under the terms of the GNU General Public License as published by
|
13 |
|
|
the Free Software Foundation; either version 3 of the License, or
|
14 |
|
|
(at your option) any later version.
|
15 |
|
|
|
16 |
|
|
This program is distributed in the hope that it will be useful,
|
17 |
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
18 |
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
19 |
|
|
GNU General Public License for more details.
|
20 |
|
|
|
21 |
|
|
You should have received a copy of the GNU General Public License
|
22 |
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
23 |
|
|
|
24 |
|
|
/* This file was derived from various remote-* modules. It is a collection
|
25 |
|
|
of generic support functions so GDB can talk directly to a ROM based
|
26 |
|
|
monitor. This saves use from having to hack an exception based handler
|
27 |
|
|
into existence, and makes for quick porting.
|
28 |
|
|
|
29 |
|
|
This module talks to a debug monitor called 'MONITOR', which
|
30 |
|
|
We communicate with MONITOR via either a direct serial line, or a TCP
|
31 |
|
|
(or possibly TELNET) stream to a terminal multiplexor,
|
32 |
|
|
which in turn talks to the target board. */
|
33 |
|
|
|
34 |
|
|
/* FIXME 32x64: This code assumes that registers and addresses are at
|
35 |
|
|
most 32 bits long. If they can be larger, you will need to declare
|
36 |
|
|
values as LONGEST and use %llx or some such to print values when
|
37 |
|
|
building commands to send to the monitor. Since we don't know of
|
38 |
|
|
any actual 64-bit targets with ROM monitors that use this code,
|
39 |
|
|
it's not an issue right now. -sts 4/18/96 */
|
40 |
|
|
|
41 |
|
|
#include "defs.h"
|
42 |
|
|
#include "gdbcore.h"
|
43 |
|
|
#include "target.h"
|
44 |
|
|
#include "exceptions.h"
|
45 |
|
|
#include <signal.h>
|
46 |
|
|
#include <ctype.h>
|
47 |
|
|
#include "gdb_string.h"
|
48 |
|
|
#include <sys/types.h>
|
49 |
|
|
#include "command.h"
|
50 |
|
|
#include "serial.h"
|
51 |
|
|
#include "monitor.h"
|
52 |
|
|
#include "gdbcmd.h"
|
53 |
|
|
#include "inferior.h"
|
54 |
|
|
#include "gdb_regex.h"
|
55 |
|
|
#include "srec.h"
|
56 |
|
|
#include "regcache.h"
|
57 |
|
|
|
58 |
|
|
static char *dev_name;
|
59 |
|
|
static struct target_ops *targ_ops;
|
60 |
|
|
|
61 |
|
|
static void monitor_interrupt_query (void);
|
62 |
|
|
static void monitor_interrupt_twice (int);
|
63 |
|
|
static void monitor_stop (void);
|
64 |
|
|
static void monitor_dump_regs (struct regcache *regcache);
|
65 |
|
|
|
66 |
|
|
#if 0
|
67 |
|
|
static int from_hex (int a);
|
68 |
|
|
#endif
|
69 |
|
|
|
70 |
|
|
static struct monitor_ops *current_monitor;
|
71 |
|
|
|
72 |
|
|
static int hashmark; /* flag set by "set hash" */
|
73 |
|
|
|
74 |
|
|
static int timeout = 30;
|
75 |
|
|
|
76 |
|
|
static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
|
77 |
|
|
|
78 |
|
|
static void (*ofunc) (); /* Old SIGINT signal handler */
|
79 |
|
|
|
80 |
|
|
static CORE_ADDR *breakaddr;
|
81 |
|
|
|
82 |
|
|
/* Descriptor for I/O to remote machine. Initialize it to NULL so
|
83 |
|
|
that monitor_open knows that we don't have a file open when the
|
84 |
|
|
program starts. */
|
85 |
|
|
|
86 |
|
|
static struct serial *monitor_desc = NULL;
|
87 |
|
|
|
88 |
|
|
/* Pointer to regexp pattern matching data */
|
89 |
|
|
|
90 |
|
|
static struct re_pattern_buffer register_pattern;
|
91 |
|
|
static char register_fastmap[256];
|
92 |
|
|
|
93 |
|
|
static struct re_pattern_buffer getmem_resp_delim_pattern;
|
94 |
|
|
static char getmem_resp_delim_fastmap[256];
|
95 |
|
|
|
96 |
|
|
static struct re_pattern_buffer setmem_resp_delim_pattern;
|
97 |
|
|
static char setmem_resp_delim_fastmap[256];
|
98 |
|
|
|
99 |
|
|
static struct re_pattern_buffer setreg_resp_delim_pattern;
|
100 |
|
|
static char setreg_resp_delim_fastmap[256];
|
101 |
|
|
|
102 |
|
|
static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
|
103 |
|
|
monitor_wait wakes up. */
|
104 |
|
|
|
105 |
|
|
static int first_time = 0; /* is this the first time we're executing after
|
106 |
|
|
gaving created the child proccess? */
|
107 |
|
|
|
108 |
|
|
#define TARGET_BUF_SIZE 2048
|
109 |
|
|
|
110 |
|
|
/* Monitor specific debugging information. Typically only useful to
|
111 |
|
|
the developer of a new monitor interface. */
|
112 |
|
|
|
113 |
|
|
static void monitor_debug (const char *fmt, ...) ATTR_FORMAT(printf, 1, 2);
|
114 |
|
|
|
115 |
|
|
static int monitor_debug_p = 0;
|
116 |
|
|
|
117 |
|
|
/* NOTE: This file alternates between monitor_debug_p and remote_debug
|
118 |
|
|
when determining if debug information is printed. Perhaps this
|
119 |
|
|
could be simplified. */
|
120 |
|
|
|
121 |
|
|
static void
|
122 |
|
|
monitor_debug (const char *fmt, ...)
|
123 |
|
|
{
|
124 |
|
|
if (monitor_debug_p)
|
125 |
|
|
{
|
126 |
|
|
va_list args;
|
127 |
|
|
va_start (args, fmt);
|
128 |
|
|
vfprintf_filtered (gdb_stdlog, fmt, args);
|
129 |
|
|
va_end (args);
|
130 |
|
|
}
|
131 |
|
|
}
|
132 |
|
|
|
133 |
|
|
|
134 |
|
|
/* Convert a string into a printable representation, Return # byte in
|
135 |
|
|
the new string. When LEN is >0 it specifies the size of the
|
136 |
|
|
string. Otherwize strlen(oldstr) is used. */
|
137 |
|
|
|
138 |
|
|
static void
|
139 |
|
|
monitor_printable_string (char *newstr, char *oldstr, int len)
|
140 |
|
|
{
|
141 |
|
|
int ch;
|
142 |
|
|
int i;
|
143 |
|
|
|
144 |
|
|
if (len <= 0)
|
145 |
|
|
len = strlen (oldstr);
|
146 |
|
|
|
147 |
|
|
for (i = 0; i < len; i++)
|
148 |
|
|
{
|
149 |
|
|
ch = oldstr[i];
|
150 |
|
|
switch (ch)
|
151 |
|
|
{
|
152 |
|
|
default:
|
153 |
|
|
if (isprint (ch))
|
154 |
|
|
*newstr++ = ch;
|
155 |
|
|
|
156 |
|
|
else
|
157 |
|
|
{
|
158 |
|
|
sprintf (newstr, "\\x%02x", ch & 0xff);
|
159 |
|
|
newstr += 4;
|
160 |
|
|
}
|
161 |
|
|
break;
|
162 |
|
|
|
163 |
|
|
case '\\':
|
164 |
|
|
*newstr++ = '\\';
|
165 |
|
|
*newstr++ = '\\';
|
166 |
|
|
break;
|
167 |
|
|
case '\b':
|
168 |
|
|
*newstr++ = '\\';
|
169 |
|
|
*newstr++ = 'b';
|
170 |
|
|
break;
|
171 |
|
|
case '\f':
|
172 |
|
|
*newstr++ = '\\';
|
173 |
|
|
*newstr++ = 't';
|
174 |
|
|
break;
|
175 |
|
|
case '\n':
|
176 |
|
|
*newstr++ = '\\';
|
177 |
|
|
*newstr++ = 'n';
|
178 |
|
|
break;
|
179 |
|
|
case '\r':
|
180 |
|
|
*newstr++ = '\\';
|
181 |
|
|
*newstr++ = 'r';
|
182 |
|
|
break;
|
183 |
|
|
case '\t':
|
184 |
|
|
*newstr++ = '\\';
|
185 |
|
|
*newstr++ = 't';
|
186 |
|
|
break;
|
187 |
|
|
case '\v':
|
188 |
|
|
*newstr++ = '\\';
|
189 |
|
|
*newstr++ = 'v';
|
190 |
|
|
break;
|
191 |
|
|
}
|
192 |
|
|
}
|
193 |
|
|
|
194 |
|
|
*newstr++ = '\0';
|
195 |
|
|
}
|
196 |
|
|
|
197 |
|
|
/* Print monitor errors with a string, converting the string to printable
|
198 |
|
|
representation. */
|
199 |
|
|
|
200 |
|
|
static void
|
201 |
|
|
monitor_error (char *function, char *message,
|
202 |
|
|
CORE_ADDR memaddr, int len, char *string, int final_char)
|
203 |
|
|
{
|
204 |
|
|
int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
|
205 |
|
|
char *safe_string = alloca ((real_len * 4) + 1);
|
206 |
|
|
monitor_printable_string (safe_string, string, real_len);
|
207 |
|
|
|
208 |
|
|
if (final_char)
|
209 |
|
|
error (_("%s (0x%s): %s: %s%c"), function, paddr_nz (memaddr), message, safe_string, final_char);
|
210 |
|
|
else
|
211 |
|
|
error (_("%s (0x%s): %s: %s"), function, paddr_nz (memaddr), message, safe_string);
|
212 |
|
|
}
|
213 |
|
|
|
214 |
|
|
/* Convert hex digit A to a number. */
|
215 |
|
|
|
216 |
|
|
static int
|
217 |
|
|
fromhex (int a)
|
218 |
|
|
{
|
219 |
|
|
if (a >= '0' && a <= '9')
|
220 |
|
|
return a - '0';
|
221 |
|
|
else if (a >= 'a' && a <= 'f')
|
222 |
|
|
return a - 'a' + 10;
|
223 |
|
|
else if (a >= 'A' && a <= 'F')
|
224 |
|
|
return a - 'A' + 10;
|
225 |
|
|
else
|
226 |
|
|
error (_("Invalid hex digit %d"), a);
|
227 |
|
|
}
|
228 |
|
|
|
229 |
|
|
/* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
|
230 |
|
|
|
231 |
|
|
This function exists to get around the problem that many host platforms
|
232 |
|
|
don't have a printf that can print 64-bit addresses. The %A format
|
233 |
|
|
specification is recognized as a special case, and causes the argument
|
234 |
|
|
to be printed as a 64-bit hexadecimal address.
|
235 |
|
|
|
236 |
|
|
Only format specifiers of the form "[0-9]*[a-z]" are recognized.
|
237 |
|
|
If it is a '%s' format, the argument is a string; otherwise the
|
238 |
|
|
argument is assumed to be a long integer.
|
239 |
|
|
|
240 |
|
|
%% is also turned into a single %.
|
241 |
|
|
*/
|
242 |
|
|
|
243 |
|
|
static void
|
244 |
|
|
monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
|
245 |
|
|
{
|
246 |
|
|
char format[10];
|
247 |
|
|
char fmt;
|
248 |
|
|
char *p;
|
249 |
|
|
int i;
|
250 |
|
|
long arg_int;
|
251 |
|
|
CORE_ADDR arg_addr;
|
252 |
|
|
char *arg_string;
|
253 |
|
|
|
254 |
|
|
for (p = pattern; *p; p++)
|
255 |
|
|
{
|
256 |
|
|
if (*p == '%')
|
257 |
|
|
{
|
258 |
|
|
/* Copy the format specifier to a separate buffer. */
|
259 |
|
|
format[0] = *p++;
|
260 |
|
|
for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
|
261 |
|
|
i++, p++)
|
262 |
|
|
format[i] = *p;
|
263 |
|
|
format[i] = fmt = *p;
|
264 |
|
|
format[i + 1] = '\0';
|
265 |
|
|
|
266 |
|
|
/* Fetch the next argument and print it. */
|
267 |
|
|
switch (fmt)
|
268 |
|
|
{
|
269 |
|
|
case '%':
|
270 |
|
|
strcpy (sndbuf, "%");
|
271 |
|
|
break;
|
272 |
|
|
case 'A':
|
273 |
|
|
arg_addr = va_arg (args, CORE_ADDR);
|
274 |
|
|
strcpy (sndbuf, paddr_nz (arg_addr));
|
275 |
|
|
break;
|
276 |
|
|
case 's':
|
277 |
|
|
arg_string = va_arg (args, char *);
|
278 |
|
|
sprintf (sndbuf, format, arg_string);
|
279 |
|
|
break;
|
280 |
|
|
default:
|
281 |
|
|
arg_int = va_arg (args, long);
|
282 |
|
|
sprintf (sndbuf, format, arg_int);
|
283 |
|
|
break;
|
284 |
|
|
}
|
285 |
|
|
sndbuf += strlen (sndbuf);
|
286 |
|
|
}
|
287 |
|
|
else
|
288 |
|
|
*sndbuf++ = *p;
|
289 |
|
|
}
|
290 |
|
|
*sndbuf = '\0';
|
291 |
|
|
}
|
292 |
|
|
|
293 |
|
|
|
294 |
|
|
/* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
|
295 |
|
|
Works just like printf. */
|
296 |
|
|
|
297 |
|
|
void
|
298 |
|
|
monitor_printf_noecho (char *pattern,...)
|
299 |
|
|
{
|
300 |
|
|
va_list args;
|
301 |
|
|
char sndbuf[2000];
|
302 |
|
|
int len;
|
303 |
|
|
|
304 |
|
|
va_start (args, pattern);
|
305 |
|
|
|
306 |
|
|
monitor_vsprintf (sndbuf, pattern, args);
|
307 |
|
|
|
308 |
|
|
len = strlen (sndbuf);
|
309 |
|
|
if (len + 1 > sizeof sndbuf)
|
310 |
|
|
internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
|
311 |
|
|
|
312 |
|
|
if (monitor_debug_p)
|
313 |
|
|
{
|
314 |
|
|
char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
|
315 |
|
|
monitor_printable_string (safe_string, sndbuf, 0);
|
316 |
|
|
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
|
317 |
|
|
}
|
318 |
|
|
|
319 |
|
|
monitor_write (sndbuf, len);
|
320 |
|
|
}
|
321 |
|
|
|
322 |
|
|
/* monitor_printf -- Send data to monitor and check the echo. Works just like
|
323 |
|
|
printf. */
|
324 |
|
|
|
325 |
|
|
void
|
326 |
|
|
monitor_printf (char *pattern,...)
|
327 |
|
|
{
|
328 |
|
|
va_list args;
|
329 |
|
|
char sndbuf[2000];
|
330 |
|
|
int len;
|
331 |
|
|
|
332 |
|
|
va_start (args, pattern);
|
333 |
|
|
|
334 |
|
|
monitor_vsprintf (sndbuf, pattern, args);
|
335 |
|
|
|
336 |
|
|
len = strlen (sndbuf);
|
337 |
|
|
if (len + 1 > sizeof sndbuf)
|
338 |
|
|
internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
|
339 |
|
|
|
340 |
|
|
if (monitor_debug_p)
|
341 |
|
|
{
|
342 |
|
|
char *safe_string = (char *) alloca ((len * 4) + 1);
|
343 |
|
|
monitor_printable_string (safe_string, sndbuf, 0);
|
344 |
|
|
fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
|
345 |
|
|
}
|
346 |
|
|
|
347 |
|
|
monitor_write (sndbuf, len);
|
348 |
|
|
|
349 |
|
|
/* We used to expect that the next immediate output was the characters we
|
350 |
|
|
just output, but sometimes some extra junk appeared before the characters
|
351 |
|
|
we expected, like an extra prompt, or a portmaster sending telnet negotiations.
|
352 |
|
|
So, just start searching for what we sent, and skip anything unknown. */
|
353 |
|
|
monitor_debug ("ExpectEcho\n");
|
354 |
|
|
monitor_expect (sndbuf, (char *) 0, 0);
|
355 |
|
|
}
|
356 |
|
|
|
357 |
|
|
|
358 |
|
|
/* Write characters to the remote system. */
|
359 |
|
|
|
360 |
|
|
void
|
361 |
|
|
monitor_write (char *buf, int buflen)
|
362 |
|
|
{
|
363 |
|
|
if (serial_write (monitor_desc, buf, buflen))
|
364 |
|
|
fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
|
365 |
|
|
safe_strerror (errno));
|
366 |
|
|
}
|
367 |
|
|
|
368 |
|
|
|
369 |
|
|
/* Read a binary character from the remote system, doing all the fancy
|
370 |
|
|
timeout stuff, but without interpreting the character in any way,
|
371 |
|
|
and without printing remote debug information. */
|
372 |
|
|
|
373 |
|
|
int
|
374 |
|
|
monitor_readchar (void)
|
375 |
|
|
{
|
376 |
|
|
int c;
|
377 |
|
|
int looping;
|
378 |
|
|
|
379 |
|
|
do
|
380 |
|
|
{
|
381 |
|
|
looping = 0;
|
382 |
|
|
c = serial_readchar (monitor_desc, timeout);
|
383 |
|
|
|
384 |
|
|
if (c >= 0)
|
385 |
|
|
c &= 0xff; /* don't lose bit 7 */
|
386 |
|
|
}
|
387 |
|
|
while (looping);
|
388 |
|
|
|
389 |
|
|
if (c >= 0)
|
390 |
|
|
return c;
|
391 |
|
|
|
392 |
|
|
if (c == SERIAL_TIMEOUT)
|
393 |
|
|
error (_("Timeout reading from remote system."));
|
394 |
|
|
|
395 |
|
|
perror_with_name (_("remote-monitor"));
|
396 |
|
|
}
|
397 |
|
|
|
398 |
|
|
|
399 |
|
|
/* Read a character from the remote system, doing all the fancy
|
400 |
|
|
timeout stuff. */
|
401 |
|
|
|
402 |
|
|
static int
|
403 |
|
|
readchar (int timeout)
|
404 |
|
|
{
|
405 |
|
|
int c;
|
406 |
|
|
static enum
|
407 |
|
|
{
|
408 |
|
|
last_random, last_nl, last_cr, last_crnl
|
409 |
|
|
}
|
410 |
|
|
state = last_random;
|
411 |
|
|
int looping;
|
412 |
|
|
|
413 |
|
|
do
|
414 |
|
|
{
|
415 |
|
|
looping = 0;
|
416 |
|
|
c = serial_readchar (monitor_desc, timeout);
|
417 |
|
|
|
418 |
|
|
if (c >= 0)
|
419 |
|
|
{
|
420 |
|
|
c &= 0x7f;
|
421 |
|
|
/* This seems to interfere with proper function of the
|
422 |
|
|
input stream */
|
423 |
|
|
if (monitor_debug_p || remote_debug)
|
424 |
|
|
{
|
425 |
|
|
char buf[2];
|
426 |
|
|
buf[0] = c;
|
427 |
|
|
buf[1] = '\0';
|
428 |
|
|
puts_debug ("read -->", buf, "<--");
|
429 |
|
|
}
|
430 |
|
|
|
431 |
|
|
}
|
432 |
|
|
|
433 |
|
|
/* Canonicialize \n\r combinations into one \r */
|
434 |
|
|
if ((current_monitor->flags & MO_HANDLE_NL) != 0)
|
435 |
|
|
{
|
436 |
|
|
if ((c == '\r' && state == last_nl)
|
437 |
|
|
|| (c == '\n' && state == last_cr))
|
438 |
|
|
{
|
439 |
|
|
state = last_crnl;
|
440 |
|
|
looping = 1;
|
441 |
|
|
}
|
442 |
|
|
else if (c == '\r')
|
443 |
|
|
state = last_cr;
|
444 |
|
|
else if (c != '\n')
|
445 |
|
|
state = last_random;
|
446 |
|
|
else
|
447 |
|
|
{
|
448 |
|
|
state = last_nl;
|
449 |
|
|
c = '\r';
|
450 |
|
|
}
|
451 |
|
|
}
|
452 |
|
|
}
|
453 |
|
|
while (looping);
|
454 |
|
|
|
455 |
|
|
if (c >= 0)
|
456 |
|
|
return c;
|
457 |
|
|
|
458 |
|
|
if (c == SERIAL_TIMEOUT)
|
459 |
|
|
#if 0
|
460 |
|
|
/* I fail to see how detaching here can be useful */
|
461 |
|
|
if (in_monitor_wait) /* Watchdog went off */
|
462 |
|
|
{
|
463 |
|
|
target_mourn_inferior ();
|
464 |
|
|
error (_("GDB serial timeout has expired. Target detached."));
|
465 |
|
|
}
|
466 |
|
|
else
|
467 |
|
|
#endif
|
468 |
|
|
error (_("Timeout reading from remote system."));
|
469 |
|
|
|
470 |
|
|
perror_with_name (_("remote-monitor"));
|
471 |
|
|
}
|
472 |
|
|
|
473 |
|
|
/* Scan input from the remote system, until STRING is found. If BUF is non-
|
474 |
|
|
zero, then collect input until we have collected either STRING or BUFLEN-1
|
475 |
|
|
chars. In either case we terminate BUF with a 0. If input overflows BUF
|
476 |
|
|
because STRING can't be found, return -1, else return number of chars in BUF
|
477 |
|
|
(minus the terminating NUL). Note that in the non-overflow case, STRING
|
478 |
|
|
will be at the end of BUF. */
|
479 |
|
|
|
480 |
|
|
int
|
481 |
|
|
monitor_expect (char *string, char *buf, int buflen)
|
482 |
|
|
{
|
483 |
|
|
char *p = string;
|
484 |
|
|
int obuflen = buflen;
|
485 |
|
|
int c;
|
486 |
|
|
|
487 |
|
|
if (monitor_debug_p)
|
488 |
|
|
{
|
489 |
|
|
char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
|
490 |
|
|
monitor_printable_string (safe_string, string, 0);
|
491 |
|
|
fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
|
492 |
|
|
}
|
493 |
|
|
|
494 |
|
|
immediate_quit++;
|
495 |
|
|
while (1)
|
496 |
|
|
{
|
497 |
|
|
if (buf)
|
498 |
|
|
{
|
499 |
|
|
if (buflen < 2)
|
500 |
|
|
{
|
501 |
|
|
*buf = '\000';
|
502 |
|
|
immediate_quit--;
|
503 |
|
|
return -1;
|
504 |
|
|
}
|
505 |
|
|
|
506 |
|
|
c = readchar (timeout);
|
507 |
|
|
if (c == '\000')
|
508 |
|
|
continue;
|
509 |
|
|
*buf++ = c;
|
510 |
|
|
buflen--;
|
511 |
|
|
}
|
512 |
|
|
else
|
513 |
|
|
c = readchar (timeout);
|
514 |
|
|
|
515 |
|
|
/* Don't expect any ^C sent to be echoed */
|
516 |
|
|
|
517 |
|
|
if (*p == '\003' || c == *p)
|
518 |
|
|
{
|
519 |
|
|
p++;
|
520 |
|
|
if (*p == '\0')
|
521 |
|
|
{
|
522 |
|
|
immediate_quit--;
|
523 |
|
|
|
524 |
|
|
if (buf)
|
525 |
|
|
{
|
526 |
|
|
*buf++ = '\000';
|
527 |
|
|
return obuflen - buflen;
|
528 |
|
|
}
|
529 |
|
|
else
|
530 |
|
|
return 0;
|
531 |
|
|
}
|
532 |
|
|
}
|
533 |
|
|
else
|
534 |
|
|
{
|
535 |
|
|
/* We got a character that doesn't match the string. We need to
|
536 |
|
|
back up p, but how far? If we're looking for "..howdy" and the
|
537 |
|
|
monitor sends "...howdy"? There's certainly a match in there,
|
538 |
|
|
but when we receive the third ".", we won't find it if we just
|
539 |
|
|
restart the matching at the beginning of the string.
|
540 |
|
|
|
541 |
|
|
This is a Boyer-Moore kind of situation. We want to reset P to
|
542 |
|
|
the end of the longest prefix of STRING that is a suffix of
|
543 |
|
|
what we've read so far. In the example above, that would be
|
544 |
|
|
".." --- the longest prefix of "..howdy" that is a suffix of
|
545 |
|
|
"...". This longest prefix could be the empty string, if C
|
546 |
|
|
is nowhere to be found in STRING.
|
547 |
|
|
|
548 |
|
|
If this longest prefix is not the empty string, it must contain
|
549 |
|
|
C, so let's search from the end of STRING for instances of C,
|
550 |
|
|
and see if the portion of STRING before that is a suffix of
|
551 |
|
|
what we read before C. Actually, we can search backwards from
|
552 |
|
|
p, since we know no prefix can be longer than that.
|
553 |
|
|
|
554 |
|
|
Note that we can use STRING itself, along with C, as a record
|
555 |
|
|
of what we've received so far. :) */
|
556 |
|
|
int i;
|
557 |
|
|
|
558 |
|
|
for (i = (p - string) - 1; i >= 0; i--)
|
559 |
|
|
if (string[i] == c)
|
560 |
|
|
{
|
561 |
|
|
/* Is this prefix a suffix of what we've read so far?
|
562 |
|
|
In other words, does
|
563 |
|
|
string[0 .. i-1] == string[p - i, p - 1]? */
|
564 |
|
|
if (! memcmp (string, p - i, i))
|
565 |
|
|
{
|
566 |
|
|
p = string + i + 1;
|
567 |
|
|
break;
|
568 |
|
|
}
|
569 |
|
|
}
|
570 |
|
|
if (i < 0)
|
571 |
|
|
p = string;
|
572 |
|
|
}
|
573 |
|
|
}
|
574 |
|
|
}
|
575 |
|
|
|
576 |
|
|
/* Search for a regexp. */
|
577 |
|
|
|
578 |
|
|
static int
|
579 |
|
|
monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
|
580 |
|
|
{
|
581 |
|
|
char *mybuf;
|
582 |
|
|
char *p;
|
583 |
|
|
monitor_debug ("MON Expecting regexp\n");
|
584 |
|
|
if (buf)
|
585 |
|
|
mybuf = buf;
|
586 |
|
|
else
|
587 |
|
|
{
|
588 |
|
|
mybuf = alloca (TARGET_BUF_SIZE);
|
589 |
|
|
buflen = TARGET_BUF_SIZE;
|
590 |
|
|
}
|
591 |
|
|
|
592 |
|
|
p = mybuf;
|
593 |
|
|
while (1)
|
594 |
|
|
{
|
595 |
|
|
int retval;
|
596 |
|
|
|
597 |
|
|
if (p - mybuf >= buflen)
|
598 |
|
|
{ /* Buffer about to overflow */
|
599 |
|
|
|
600 |
|
|
/* On overflow, we copy the upper half of the buffer to the lower half. Not
|
601 |
|
|
great, but it usually works... */
|
602 |
|
|
|
603 |
|
|
memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
|
604 |
|
|
p = mybuf + buflen / 2;
|
605 |
|
|
}
|
606 |
|
|
|
607 |
|
|
*p++ = readchar (timeout);
|
608 |
|
|
|
609 |
|
|
retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
|
610 |
|
|
if (retval >= 0)
|
611 |
|
|
return 1;
|
612 |
|
|
}
|
613 |
|
|
}
|
614 |
|
|
|
615 |
|
|
/* Keep discarding input until we see the MONITOR prompt.
|
616 |
|
|
|
617 |
|
|
The convention for dealing with the prompt is that you
|
618 |
|
|
o give your command
|
619 |
|
|
o *then* wait for the prompt.
|
620 |
|
|
|
621 |
|
|
Thus the last thing that a procedure does with the serial line will
|
622 |
|
|
be an monitor_expect_prompt(). Exception: monitor_resume does not
|
623 |
|
|
wait for the prompt, because the terminal is being handed over to
|
624 |
|
|
the inferior. However, the next thing which happens after that is
|
625 |
|
|
a monitor_wait which does wait for the prompt. Note that this
|
626 |
|
|
includes abnormal exit, e.g. error(). This is necessary to prevent
|
627 |
|
|
getting into states from which we can't recover. */
|
628 |
|
|
|
629 |
|
|
int
|
630 |
|
|
monitor_expect_prompt (char *buf, int buflen)
|
631 |
|
|
{
|
632 |
|
|
monitor_debug ("MON Expecting prompt\n");
|
633 |
|
|
return monitor_expect (current_monitor->prompt, buf, buflen);
|
634 |
|
|
}
|
635 |
|
|
|
636 |
|
|
/* Get N 32-bit words from remote, each preceded by a space, and put
|
637 |
|
|
them in registers starting at REGNO. */
|
638 |
|
|
|
639 |
|
|
#if 0
|
640 |
|
|
static unsigned long
|
641 |
|
|
get_hex_word (void)
|
642 |
|
|
{
|
643 |
|
|
unsigned long val;
|
644 |
|
|
int i;
|
645 |
|
|
int ch;
|
646 |
|
|
|
647 |
|
|
do
|
648 |
|
|
ch = readchar (timeout);
|
649 |
|
|
while (isspace (ch));
|
650 |
|
|
|
651 |
|
|
val = from_hex (ch);
|
652 |
|
|
|
653 |
|
|
for (i = 7; i >= 1; i--)
|
654 |
|
|
{
|
655 |
|
|
ch = readchar (timeout);
|
656 |
|
|
if (!isxdigit (ch))
|
657 |
|
|
break;
|
658 |
|
|
val = (val << 4) | from_hex (ch);
|
659 |
|
|
}
|
660 |
|
|
|
661 |
|
|
return val;
|
662 |
|
|
}
|
663 |
|
|
#endif
|
664 |
|
|
|
665 |
|
|
static void
|
666 |
|
|
compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
|
667 |
|
|
char *fastmap)
|
668 |
|
|
{
|
669 |
|
|
int tmp;
|
670 |
|
|
const char *val;
|
671 |
|
|
|
672 |
|
|
compiled_pattern->fastmap = fastmap;
|
673 |
|
|
|
674 |
|
|
tmp = re_set_syntax (RE_SYNTAX_EMACS);
|
675 |
|
|
val = re_compile_pattern (pattern,
|
676 |
|
|
strlen (pattern),
|
677 |
|
|
compiled_pattern);
|
678 |
|
|
re_set_syntax (tmp);
|
679 |
|
|
|
680 |
|
|
if (val)
|
681 |
|
|
error (_("compile_pattern: Can't compile pattern string `%s': %s!"), pattern, val);
|
682 |
|
|
|
683 |
|
|
if (fastmap)
|
684 |
|
|
re_compile_fastmap (compiled_pattern);
|
685 |
|
|
}
|
686 |
|
|
|
687 |
|
|
/* Open a connection to a remote debugger. NAME is the filename used
|
688 |
|
|
for communication. */
|
689 |
|
|
|
690 |
|
|
void
|
691 |
|
|
monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
|
692 |
|
|
{
|
693 |
|
|
char *name;
|
694 |
|
|
char **p;
|
695 |
|
|
|
696 |
|
|
if (mon_ops->magic != MONITOR_OPS_MAGIC)
|
697 |
|
|
error (_("Magic number of monitor_ops struct wrong."));
|
698 |
|
|
|
699 |
|
|
targ_ops = mon_ops->target;
|
700 |
|
|
name = targ_ops->to_shortname;
|
701 |
|
|
|
702 |
|
|
if (!args)
|
703 |
|
|
error (_("Use `target %s DEVICE-NAME' to use a serial port, or \n\
|
704 |
|
|
`target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);
|
705 |
|
|
|
706 |
|
|
target_preopen (from_tty);
|
707 |
|
|
|
708 |
|
|
/* Setup pattern for register dump */
|
709 |
|
|
|
710 |
|
|
if (mon_ops->register_pattern)
|
711 |
|
|
compile_pattern (mon_ops->register_pattern, ®ister_pattern,
|
712 |
|
|
register_fastmap);
|
713 |
|
|
|
714 |
|
|
if (mon_ops->getmem.resp_delim)
|
715 |
|
|
compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
|
716 |
|
|
getmem_resp_delim_fastmap);
|
717 |
|
|
|
718 |
|
|
if (mon_ops->setmem.resp_delim)
|
719 |
|
|
compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
|
720 |
|
|
setmem_resp_delim_fastmap);
|
721 |
|
|
|
722 |
|
|
if (mon_ops->setreg.resp_delim)
|
723 |
|
|
compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
|
724 |
|
|
setreg_resp_delim_fastmap);
|
725 |
|
|
|
726 |
|
|
unpush_target (targ_ops);
|
727 |
|
|
|
728 |
|
|
if (dev_name)
|
729 |
|
|
xfree (dev_name);
|
730 |
|
|
dev_name = xstrdup (args);
|
731 |
|
|
|
732 |
|
|
monitor_desc = serial_open (dev_name);
|
733 |
|
|
|
734 |
|
|
if (!monitor_desc)
|
735 |
|
|
perror_with_name (dev_name);
|
736 |
|
|
|
737 |
|
|
if (baud_rate != -1)
|
738 |
|
|
{
|
739 |
|
|
if (serial_setbaudrate (monitor_desc, baud_rate))
|
740 |
|
|
{
|
741 |
|
|
serial_close (monitor_desc);
|
742 |
|
|
perror_with_name (dev_name);
|
743 |
|
|
}
|
744 |
|
|
}
|
745 |
|
|
|
746 |
|
|
serial_raw (monitor_desc);
|
747 |
|
|
|
748 |
|
|
serial_flush_input (monitor_desc);
|
749 |
|
|
|
750 |
|
|
/* some systems only work with 2 stop bits */
|
751 |
|
|
|
752 |
|
|
serial_setstopbits (monitor_desc, mon_ops->stopbits);
|
753 |
|
|
|
754 |
|
|
current_monitor = mon_ops;
|
755 |
|
|
|
756 |
|
|
/* See if we can wake up the monitor. First, try sending a stop sequence,
|
757 |
|
|
then send the init strings. Last, remove all breakpoints. */
|
758 |
|
|
|
759 |
|
|
if (current_monitor->stop)
|
760 |
|
|
{
|
761 |
|
|
monitor_stop ();
|
762 |
|
|
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
|
763 |
|
|
{
|
764 |
|
|
monitor_debug ("EXP Open echo\n");
|
765 |
|
|
monitor_expect_prompt (NULL, 0);
|
766 |
|
|
}
|
767 |
|
|
}
|
768 |
|
|
|
769 |
|
|
/* wake up the monitor and see if it's alive */
|
770 |
|
|
for (p = mon_ops->init; *p != NULL; p++)
|
771 |
|
|
{
|
772 |
|
|
/* Some of the characters we send may not be echoed,
|
773 |
|
|
but we hope to get a prompt at the end of it all. */
|
774 |
|
|
|
775 |
|
|
if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
|
776 |
|
|
monitor_printf (*p);
|
777 |
|
|
else
|
778 |
|
|
monitor_printf_noecho (*p);
|
779 |
|
|
monitor_expect_prompt (NULL, 0);
|
780 |
|
|
}
|
781 |
|
|
|
782 |
|
|
serial_flush_input (monitor_desc);
|
783 |
|
|
|
784 |
|
|
/* Alloc breakpoints */
|
785 |
|
|
if (mon_ops->set_break != NULL)
|
786 |
|
|
{
|
787 |
|
|
if (mon_ops->num_breakpoints == 0)
|
788 |
|
|
mon_ops->num_breakpoints = 8;
|
789 |
|
|
|
790 |
|
|
breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
|
791 |
|
|
memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
|
792 |
|
|
}
|
793 |
|
|
|
794 |
|
|
/* Remove all breakpoints */
|
795 |
|
|
|
796 |
|
|
if (mon_ops->clr_all_break)
|
797 |
|
|
{
|
798 |
|
|
monitor_printf (mon_ops->clr_all_break);
|
799 |
|
|
monitor_expect_prompt (NULL, 0);
|
800 |
|
|
}
|
801 |
|
|
|
802 |
|
|
if (from_tty)
|
803 |
|
|
printf_unfiltered (_("Remote target %s connected to %s\n"), name, dev_name);
|
804 |
|
|
|
805 |
|
|
push_target (targ_ops);
|
806 |
|
|
|
807 |
|
|
inferior_ptid = pid_to_ptid (42000); /* Make run command think we are busy... */
|
808 |
|
|
|
809 |
|
|
/* Give monitor_wait something to read */
|
810 |
|
|
|
811 |
|
|
monitor_printf (current_monitor->line_term);
|
812 |
|
|
|
813 |
|
|
start_remote (from_tty);
|
814 |
|
|
}
|
815 |
|
|
|
816 |
|
|
/* Close out all files and local state before this target loses
|
817 |
|
|
control. */
|
818 |
|
|
|
819 |
|
|
void
|
820 |
|
|
monitor_close (int quitting)
|
821 |
|
|
{
|
822 |
|
|
if (monitor_desc)
|
823 |
|
|
serial_close (monitor_desc);
|
824 |
|
|
|
825 |
|
|
/* Free breakpoint memory */
|
826 |
|
|
if (breakaddr != NULL)
|
827 |
|
|
{
|
828 |
|
|
xfree (breakaddr);
|
829 |
|
|
breakaddr = NULL;
|
830 |
|
|
}
|
831 |
|
|
|
832 |
|
|
monitor_desc = NULL;
|
833 |
|
|
}
|
834 |
|
|
|
835 |
|
|
/* Terminate the open connection to the remote debugger. Use this
|
836 |
|
|
when you want to detach and do something else with your gdb. */
|
837 |
|
|
|
838 |
|
|
static void
|
839 |
|
|
monitor_detach (char *args, int from_tty)
|
840 |
|
|
{
|
841 |
|
|
pop_target (); /* calls monitor_close to do the real work */
|
842 |
|
|
if (from_tty)
|
843 |
|
|
printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
|
844 |
|
|
}
|
845 |
|
|
|
846 |
|
|
/* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
|
847 |
|
|
|
848 |
|
|
char *
|
849 |
|
|
monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
|
850 |
|
|
{
|
851 |
|
|
ULONGEST val;
|
852 |
|
|
unsigned char regbuf[MAX_REGISTER_SIZE];
|
853 |
|
|
char *p;
|
854 |
|
|
|
855 |
|
|
val = 0;
|
856 |
|
|
p = valstr;
|
857 |
|
|
while (p && *p != '\0')
|
858 |
|
|
{
|
859 |
|
|
if (*p == '\r' || *p == '\n')
|
860 |
|
|
{
|
861 |
|
|
while (*p != '\0')
|
862 |
|
|
p++;
|
863 |
|
|
break;
|
864 |
|
|
}
|
865 |
|
|
if (isspace (*p))
|
866 |
|
|
{
|
867 |
|
|
p++;
|
868 |
|
|
continue;
|
869 |
|
|
}
|
870 |
|
|
if (!isxdigit (*p) && *p != 'x')
|
871 |
|
|
{
|
872 |
|
|
break;
|
873 |
|
|
}
|
874 |
|
|
|
875 |
|
|
val <<= 4;
|
876 |
|
|
val += fromhex (*p++);
|
877 |
|
|
}
|
878 |
|
|
monitor_debug ("Supplying Register %d %s\n", regno, valstr);
|
879 |
|
|
|
880 |
|
|
if (val == 0 && valstr == p)
|
881 |
|
|
error (_("monitor_supply_register (%d): bad value from monitor: %s."),
|
882 |
|
|
regno, valstr);
|
883 |
|
|
|
884 |
|
|
/* supply register stores in target byte order, so swap here */
|
885 |
|
|
|
886 |
|
|
store_unsigned_integer (regbuf,
|
887 |
|
|
register_size (get_regcache_arch (regcache), regno),
|
888 |
|
|
val);
|
889 |
|
|
|
890 |
|
|
regcache_raw_supply (regcache, regno, regbuf);
|
891 |
|
|
|
892 |
|
|
return p;
|
893 |
|
|
}
|
894 |
|
|
|
895 |
|
|
/* Tell the remote machine to resume. */
|
896 |
|
|
|
897 |
|
|
static void
|
898 |
|
|
monitor_resume (ptid_t ptid, int step, enum target_signal sig)
|
899 |
|
|
{
|
900 |
|
|
/* Some monitors require a different command when starting a program */
|
901 |
|
|
monitor_debug ("MON resume\n");
|
902 |
|
|
if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
|
903 |
|
|
{
|
904 |
|
|
first_time = 0;
|
905 |
|
|
monitor_printf ("run\r");
|
906 |
|
|
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
|
907 |
|
|
dump_reg_flag = 1;
|
908 |
|
|
return;
|
909 |
|
|
}
|
910 |
|
|
if (step)
|
911 |
|
|
monitor_printf (current_monitor->step);
|
912 |
|
|
else
|
913 |
|
|
{
|
914 |
|
|
if (current_monitor->continue_hook)
|
915 |
|
|
(*current_monitor->continue_hook) ();
|
916 |
|
|
else
|
917 |
|
|
monitor_printf (current_monitor->cont);
|
918 |
|
|
if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
|
919 |
|
|
dump_reg_flag = 1;
|
920 |
|
|
}
|
921 |
|
|
}
|
922 |
|
|
|
923 |
|
|
/* Parse the output of a register dump command. A monitor specific
|
924 |
|
|
regexp is used to extract individual register descriptions of the
|
925 |
|
|
form REG=VAL. Each description is split up into a name and a value
|
926 |
|
|
string which are passed down to monitor specific code. */
|
927 |
|
|
|
928 |
|
|
static void
|
929 |
|
|
parse_register_dump (struct regcache *regcache, char *buf, int len)
|
930 |
|
|
{
|
931 |
|
|
monitor_debug ("MON Parsing register dump\n");
|
932 |
|
|
while (1)
|
933 |
|
|
{
|
934 |
|
|
int regnamelen, vallen;
|
935 |
|
|
char *regname, *val;
|
936 |
|
|
/* Element 0 points to start of register name, and element 1
|
937 |
|
|
points to the start of the register value. */
|
938 |
|
|
struct re_registers register_strings;
|
939 |
|
|
|
940 |
|
|
memset (®ister_strings, 0, sizeof (struct re_registers));
|
941 |
|
|
|
942 |
|
|
if (re_search (®ister_pattern, buf, len, 0, len,
|
943 |
|
|
®ister_strings) == -1)
|
944 |
|
|
break;
|
945 |
|
|
|
946 |
|
|
regnamelen = register_strings.end[1] - register_strings.start[1];
|
947 |
|
|
regname = buf + register_strings.start[1];
|
948 |
|
|
vallen = register_strings.end[2] - register_strings.start[2];
|
949 |
|
|
val = buf + register_strings.start[2];
|
950 |
|
|
|
951 |
|
|
current_monitor->supply_register (regcache, regname, regnamelen,
|
952 |
|
|
val, vallen);
|
953 |
|
|
|
954 |
|
|
buf += register_strings.end[0];
|
955 |
|
|
len -= register_strings.end[0];
|
956 |
|
|
}
|
957 |
|
|
}
|
958 |
|
|
|
959 |
|
|
/* Send ^C to target to halt it. Target will respond, and send us a
|
960 |
|
|
packet. */
|
961 |
|
|
|
962 |
|
|
static void
|
963 |
|
|
monitor_interrupt (int signo)
|
964 |
|
|
{
|
965 |
|
|
/* If this doesn't work, try more severe steps. */
|
966 |
|
|
signal (signo, monitor_interrupt_twice);
|
967 |
|
|
|
968 |
|
|
if (monitor_debug_p || remote_debug)
|
969 |
|
|
fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
|
970 |
|
|
|
971 |
|
|
target_stop ();
|
972 |
|
|
}
|
973 |
|
|
|
974 |
|
|
/* The user typed ^C twice. */
|
975 |
|
|
|
976 |
|
|
static void
|
977 |
|
|
monitor_interrupt_twice (int signo)
|
978 |
|
|
{
|
979 |
|
|
signal (signo, ofunc);
|
980 |
|
|
|
981 |
|
|
monitor_interrupt_query ();
|
982 |
|
|
|
983 |
|
|
signal (signo, monitor_interrupt);
|
984 |
|
|
}
|
985 |
|
|
|
986 |
|
|
/* Ask the user what to do when an interrupt is received. */
|
987 |
|
|
|
988 |
|
|
static void
|
989 |
|
|
monitor_interrupt_query (void)
|
990 |
|
|
{
|
991 |
|
|
target_terminal_ours ();
|
992 |
|
|
|
993 |
|
|
if (query ("Interrupted while waiting for the program.\n\
|
994 |
|
|
Give up (and stop debugging it)? "))
|
995 |
|
|
{
|
996 |
|
|
target_mourn_inferior ();
|
997 |
|
|
deprecated_throw_reason (RETURN_QUIT);
|
998 |
|
|
}
|
999 |
|
|
|
1000 |
|
|
target_terminal_inferior ();
|
1001 |
|
|
}
|
1002 |
|
|
|
1003 |
|
|
static void
|
1004 |
|
|
monitor_wait_cleanup (void *old_timeout)
|
1005 |
|
|
{
|
1006 |
|
|
timeout = *(int *) old_timeout;
|
1007 |
|
|
signal (SIGINT, ofunc);
|
1008 |
|
|
in_monitor_wait = 0;
|
1009 |
|
|
}
|
1010 |
|
|
|
1011 |
|
|
|
1012 |
|
|
|
1013 |
|
|
static void
|
1014 |
|
|
monitor_wait_filter (char *buf,
|
1015 |
|
|
int bufmax,
|
1016 |
|
|
int *ext_resp_len,
|
1017 |
|
|
struct target_waitstatus *status)
|
1018 |
|
|
{
|
1019 |
|
|
int resp_len;
|
1020 |
|
|
do
|
1021 |
|
|
{
|
1022 |
|
|
resp_len = monitor_expect_prompt (buf, bufmax);
|
1023 |
|
|
*ext_resp_len = resp_len;
|
1024 |
|
|
|
1025 |
|
|
if (resp_len <= 0)
|
1026 |
|
|
fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
|
1027 |
|
|
}
|
1028 |
|
|
while (resp_len < 0);
|
1029 |
|
|
|
1030 |
|
|
/* Print any output characters that were preceded by ^O. */
|
1031 |
|
|
/* FIXME - This would be great as a user settabgle flag */
|
1032 |
|
|
if (monitor_debug_p || remote_debug
|
1033 |
|
|
|| current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
|
1034 |
|
|
{
|
1035 |
|
|
int i;
|
1036 |
|
|
|
1037 |
|
|
for (i = 0; i < resp_len - 1; i++)
|
1038 |
|
|
if (buf[i] == 0x0f)
|
1039 |
|
|
putchar_unfiltered (buf[++i]);
|
1040 |
|
|
}
|
1041 |
|
|
}
|
1042 |
|
|
|
1043 |
|
|
|
1044 |
|
|
|
1045 |
|
|
/* Wait until the remote machine stops, then return, storing status in
|
1046 |
|
|
status just as `wait' would. */
|
1047 |
|
|
|
1048 |
|
|
static ptid_t
|
1049 |
|
|
monitor_wait (ptid_t ptid, struct target_waitstatus *status)
|
1050 |
|
|
{
|
1051 |
|
|
int old_timeout = timeout;
|
1052 |
|
|
char buf[TARGET_BUF_SIZE];
|
1053 |
|
|
int resp_len;
|
1054 |
|
|
struct cleanup *old_chain;
|
1055 |
|
|
|
1056 |
|
|
status->kind = TARGET_WAITKIND_EXITED;
|
1057 |
|
|
status->value.integer = 0;
|
1058 |
|
|
|
1059 |
|
|
old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
|
1060 |
|
|
monitor_debug ("MON wait\n");
|
1061 |
|
|
|
1062 |
|
|
#if 0
|
1063 |
|
|
/* This is somthing other than a maintenance command */
|
1064 |
|
|
in_monitor_wait = 1;
|
1065 |
|
|
timeout = watchdog > 0 ? watchdog : -1;
|
1066 |
|
|
#else
|
1067 |
|
|
timeout = -1; /* Don't time out -- user program is running. */
|
1068 |
|
|
#endif
|
1069 |
|
|
|
1070 |
|
|
ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
|
1071 |
|
|
|
1072 |
|
|
if (current_monitor->wait_filter)
|
1073 |
|
|
(*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
|
1074 |
|
|
else
|
1075 |
|
|
monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
|
1076 |
|
|
|
1077 |
|
|
#if 0 /* Transferred to monitor wait filter */
|
1078 |
|
|
do
|
1079 |
|
|
{
|
1080 |
|
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
1081 |
|
|
|
1082 |
|
|
if (resp_len <= 0)
|
1083 |
|
|
fprintf_unfiltered (gdb_stderr, "monitor_wait: excessive response from monitor: %s.", buf);
|
1084 |
|
|
}
|
1085 |
|
|
while (resp_len < 0);
|
1086 |
|
|
|
1087 |
|
|
/* Print any output characters that were preceded by ^O. */
|
1088 |
|
|
/* FIXME - This would be great as a user settabgle flag */
|
1089 |
|
|
if (monitor_debug_p || remote_debug
|
1090 |
|
|
|| current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
|
1091 |
|
|
{
|
1092 |
|
|
int i;
|
1093 |
|
|
|
1094 |
|
|
for (i = 0; i < resp_len - 1; i++)
|
1095 |
|
|
if (buf[i] == 0x0f)
|
1096 |
|
|
putchar_unfiltered (buf[++i]);
|
1097 |
|
|
}
|
1098 |
|
|
#endif
|
1099 |
|
|
|
1100 |
|
|
signal (SIGINT, ofunc);
|
1101 |
|
|
|
1102 |
|
|
timeout = old_timeout;
|
1103 |
|
|
#if 0
|
1104 |
|
|
if (dump_reg_flag && current_monitor->dump_registers)
|
1105 |
|
|
{
|
1106 |
|
|
dump_reg_flag = 0;
|
1107 |
|
|
monitor_printf (current_monitor->dump_registers);
|
1108 |
|
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
1109 |
|
|
}
|
1110 |
|
|
|
1111 |
|
|
if (current_monitor->register_pattern)
|
1112 |
|
|
parse_register_dump (get_current_regcache (), buf, resp_len);
|
1113 |
|
|
#else
|
1114 |
|
|
monitor_debug ("Wait fetching registers after stop\n");
|
1115 |
|
|
monitor_dump_regs (get_current_regcache ());
|
1116 |
|
|
#endif
|
1117 |
|
|
|
1118 |
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
1119 |
|
|
status->value.sig = TARGET_SIGNAL_TRAP;
|
1120 |
|
|
|
1121 |
|
|
discard_cleanups (old_chain);
|
1122 |
|
|
|
1123 |
|
|
in_monitor_wait = 0;
|
1124 |
|
|
|
1125 |
|
|
return inferior_ptid;
|
1126 |
|
|
}
|
1127 |
|
|
|
1128 |
|
|
/* Fetch register REGNO, or all registers if REGNO is -1. Returns
|
1129 |
|
|
errno value. */
|
1130 |
|
|
|
1131 |
|
|
static void
|
1132 |
|
|
monitor_fetch_register (struct regcache *regcache, int regno)
|
1133 |
|
|
{
|
1134 |
|
|
const char *name;
|
1135 |
|
|
char *zerobuf;
|
1136 |
|
|
char *regbuf;
|
1137 |
|
|
int i;
|
1138 |
|
|
|
1139 |
|
|
regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1);
|
1140 |
|
|
zerobuf = alloca (MAX_REGISTER_SIZE);
|
1141 |
|
|
memset (zerobuf, 0, MAX_REGISTER_SIZE);
|
1142 |
|
|
|
1143 |
|
|
if (current_monitor->regname != NULL)
|
1144 |
|
|
name = current_monitor->regname (regno);
|
1145 |
|
|
else
|
1146 |
|
|
name = current_monitor->regnames[regno];
|
1147 |
|
|
monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
|
1148 |
|
|
|
1149 |
|
|
if (!name || (*name == '\0'))
|
1150 |
|
|
{
|
1151 |
|
|
monitor_debug ("No register known for %d\n", regno);
|
1152 |
|
|
regcache_raw_supply (regcache, regno, zerobuf);
|
1153 |
|
|
return;
|
1154 |
|
|
}
|
1155 |
|
|
|
1156 |
|
|
/* send the register examine command */
|
1157 |
|
|
|
1158 |
|
|
monitor_printf (current_monitor->getreg.cmd, name);
|
1159 |
|
|
|
1160 |
|
|
/* If RESP_DELIM is specified, we search for that as a leading
|
1161 |
|
|
delimiter for the register value. Otherwise, we just start
|
1162 |
|
|
searching from the start of the buf. */
|
1163 |
|
|
|
1164 |
|
|
if (current_monitor->getreg.resp_delim)
|
1165 |
|
|
{
|
1166 |
|
|
monitor_debug ("EXP getreg.resp_delim\n");
|
1167 |
|
|
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
|
1168 |
|
|
/* Handle case of first 32 registers listed in pairs. */
|
1169 |
|
|
if (current_monitor->flags & MO_32_REGS_PAIRED
|
1170 |
|
|
&& (regno & 1) != 0 && regno < 32)
|
1171 |
|
|
{
|
1172 |
|
|
monitor_debug ("EXP getreg.resp_delim\n");
|
1173 |
|
|
monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
|
1174 |
|
|
}
|
1175 |
|
|
}
|
1176 |
|
|
|
1177 |
|
|
/* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
|
1178 |
|
|
if (current_monitor->flags & MO_HEX_PREFIX)
|
1179 |
|
|
{
|
1180 |
|
|
int c;
|
1181 |
|
|
c = readchar (timeout);
|
1182 |
|
|
while (c == ' ')
|
1183 |
|
|
c = readchar (timeout);
|
1184 |
|
|
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
|
1185 |
|
|
;
|
1186 |
|
|
else
|
1187 |
|
|
error (_("Bad value returned from monitor while fetching register %x."),
|
1188 |
|
|
regno);
|
1189 |
|
|
}
|
1190 |
|
|
|
1191 |
|
|
/* Read upto the maximum number of hex digits for this register, skipping
|
1192 |
|
|
spaces, but stop reading if something else is seen. Some monitors
|
1193 |
|
|
like to drop leading zeros. */
|
1194 |
|
|
|
1195 |
|
|
for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)
|
1196 |
|
|
{
|
1197 |
|
|
int c;
|
1198 |
|
|
c = readchar (timeout);
|
1199 |
|
|
while (c == ' ')
|
1200 |
|
|
c = readchar (timeout);
|
1201 |
|
|
|
1202 |
|
|
if (!isxdigit (c))
|
1203 |
|
|
break;
|
1204 |
|
|
|
1205 |
|
|
regbuf[i] = c;
|
1206 |
|
|
}
|
1207 |
|
|
|
1208 |
|
|
regbuf[i] = '\000'; /* terminate the number */
|
1209 |
|
|
monitor_debug ("REGVAL '%s'\n", regbuf);
|
1210 |
|
|
|
1211 |
|
|
/* If TERM is present, we wait for that to show up. Also, (if TERM
|
1212 |
|
|
is present), we will send TERM_CMD if that is present. In any
|
1213 |
|
|
case, we collect all of the output into buf, and then wait for
|
1214 |
|
|
the normal prompt. */
|
1215 |
|
|
|
1216 |
|
|
if (current_monitor->getreg.term)
|
1217 |
|
|
{
|
1218 |
|
|
monitor_debug ("EXP getreg.term\n");
|
1219 |
|
|
monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
|
1220 |
|
|
}
|
1221 |
|
|
|
1222 |
|
|
if (current_monitor->getreg.term_cmd)
|
1223 |
|
|
{
|
1224 |
|
|
monitor_debug ("EMIT getreg.term.cmd\n");
|
1225 |
|
|
monitor_printf (current_monitor->getreg.term_cmd);
|
1226 |
|
|
}
|
1227 |
|
|
if (!current_monitor->getreg.term || /* Already expected or */
|
1228 |
|
|
current_monitor->getreg.term_cmd) /* ack expected */
|
1229 |
|
|
monitor_expect_prompt (NULL, 0); /* get response */
|
1230 |
|
|
|
1231 |
|
|
monitor_supply_register (regcache, regno, regbuf);
|
1232 |
|
|
}
|
1233 |
|
|
|
1234 |
|
|
/* Sometimes, it takes several commands to dump the registers */
|
1235 |
|
|
/* This is a primitive for use by variations of monitor interfaces in
|
1236 |
|
|
case they need to compose the operation.
|
1237 |
|
|
*/
|
1238 |
|
|
int
|
1239 |
|
|
monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)
|
1240 |
|
|
{
|
1241 |
|
|
char buf[TARGET_BUF_SIZE];
|
1242 |
|
|
int resp_len;
|
1243 |
|
|
monitor_printf (block_cmd);
|
1244 |
|
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
1245 |
|
|
parse_register_dump (regcache, buf, resp_len);
|
1246 |
|
|
return 1;
|
1247 |
|
|
}
|
1248 |
|
|
|
1249 |
|
|
|
1250 |
|
|
/* Read the remote registers into the block regs. */
|
1251 |
|
|
/* Call the specific function if it has been provided */
|
1252 |
|
|
|
1253 |
|
|
static void
|
1254 |
|
|
monitor_dump_regs (struct regcache *regcache)
|
1255 |
|
|
{
|
1256 |
|
|
char buf[TARGET_BUF_SIZE];
|
1257 |
|
|
int resp_len;
|
1258 |
|
|
if (current_monitor->dumpregs)
|
1259 |
|
|
(*(current_monitor->dumpregs)) (regcache); /* call supplied function */
|
1260 |
|
|
else if (current_monitor->dump_registers) /* default version */
|
1261 |
|
|
{
|
1262 |
|
|
monitor_printf (current_monitor->dump_registers);
|
1263 |
|
|
resp_len = monitor_expect_prompt (buf, sizeof (buf));
|
1264 |
|
|
parse_register_dump (regcache, buf, resp_len);
|
1265 |
|
|
}
|
1266 |
|
|
else
|
1267 |
|
|
internal_error (__FILE__, __LINE__, _("failed internal consistency check")); /* Need some way to read registers */
|
1268 |
|
|
}
|
1269 |
|
|
|
1270 |
|
|
static void
|
1271 |
|
|
monitor_fetch_registers (struct regcache *regcache, int regno)
|
1272 |
|
|
{
|
1273 |
|
|
monitor_debug ("MON fetchregs\n");
|
1274 |
|
|
if (current_monitor->getreg.cmd)
|
1275 |
|
|
{
|
1276 |
|
|
if (regno >= 0)
|
1277 |
|
|
{
|
1278 |
|
|
monitor_fetch_register (regcache, regno);
|
1279 |
|
|
return;
|
1280 |
|
|
}
|
1281 |
|
|
|
1282 |
|
|
for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
|
1283 |
|
|
regno++)
|
1284 |
|
|
monitor_fetch_register (regcache, regno);
|
1285 |
|
|
}
|
1286 |
|
|
else
|
1287 |
|
|
{
|
1288 |
|
|
monitor_dump_regs (regcache);
|
1289 |
|
|
}
|
1290 |
|
|
}
|
1291 |
|
|
|
1292 |
|
|
/* Store register REGNO, or all if REGNO == 0. Return errno value. */
|
1293 |
|
|
|
1294 |
|
|
static void
|
1295 |
|
|
monitor_store_register (struct regcache *regcache, int regno)
|
1296 |
|
|
{
|
1297 |
|
|
const char *name;
|
1298 |
|
|
ULONGEST val;
|
1299 |
|
|
|
1300 |
|
|
if (current_monitor->regname != NULL)
|
1301 |
|
|
name = current_monitor->regname (regno);
|
1302 |
|
|
else
|
1303 |
|
|
name = current_monitor->regnames[regno];
|
1304 |
|
|
|
1305 |
|
|
if (!name || (*name == '\0'))
|
1306 |
|
|
{
|
1307 |
|
|
monitor_debug ("MON Cannot store unknown register\n");
|
1308 |
|
|
return;
|
1309 |
|
|
}
|
1310 |
|
|
|
1311 |
|
|
regcache_cooked_read_unsigned (regcache, regno, &val);
|
1312 |
|
|
monitor_debug ("MON storeg %d %s\n", regno,
|
1313 |
|
|
phex (val,
|
1314 |
|
|
register_size (get_regcache_arch (regcache), regno)));
|
1315 |
|
|
|
1316 |
|
|
/* send the register deposit command */
|
1317 |
|
|
|
1318 |
|
|
if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
|
1319 |
|
|
monitor_printf (current_monitor->setreg.cmd, val, name);
|
1320 |
|
|
else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
1321 |
|
|
monitor_printf (current_monitor->setreg.cmd, name);
|
1322 |
|
|
else
|
1323 |
|
|
monitor_printf (current_monitor->setreg.cmd, name, val);
|
1324 |
|
|
|
1325 |
|
|
if (current_monitor->setreg.resp_delim)
|
1326 |
|
|
{
|
1327 |
|
|
monitor_debug ("EXP setreg.resp_delim\n");
|
1328 |
|
|
monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
|
1329 |
|
|
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
1330 |
|
|
monitor_printf ("%s\r", paddr_nz (val));
|
1331 |
|
|
}
|
1332 |
|
|
if (current_monitor->setreg.term)
|
1333 |
|
|
{
|
1334 |
|
|
monitor_debug ("EXP setreg.term\n");
|
1335 |
|
|
monitor_expect (current_monitor->setreg.term, NULL, 0);
|
1336 |
|
|
if (current_monitor->flags & MO_SETREG_INTERACTIVE)
|
1337 |
|
|
monitor_printf ("%s\r", paddr_nz (val));
|
1338 |
|
|
monitor_expect_prompt (NULL, 0);
|
1339 |
|
|
}
|
1340 |
|
|
else
|
1341 |
|
|
monitor_expect_prompt (NULL, 0);
|
1342 |
|
|
if (current_monitor->setreg.term_cmd) /* Mode exit required */
|
1343 |
|
|
{
|
1344 |
|
|
monitor_debug ("EXP setreg_termcmd\n");
|
1345 |
|
|
monitor_printf ("%s", current_monitor->setreg.term_cmd);
|
1346 |
|
|
monitor_expect_prompt (NULL, 0);
|
1347 |
|
|
}
|
1348 |
|
|
} /* monitor_store_register */
|
1349 |
|
|
|
1350 |
|
|
/* Store the remote registers. */
|
1351 |
|
|
|
1352 |
|
|
static void
|
1353 |
|
|
monitor_store_registers (struct regcache *regcache, int regno)
|
1354 |
|
|
{
|
1355 |
|
|
if (regno >= 0)
|
1356 |
|
|
{
|
1357 |
|
|
monitor_store_register (regcache, regno);
|
1358 |
|
|
return;
|
1359 |
|
|
}
|
1360 |
|
|
|
1361 |
|
|
for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
|
1362 |
|
|
regno++)
|
1363 |
|
|
monitor_store_register (regcache, regno);
|
1364 |
|
|
}
|
1365 |
|
|
|
1366 |
|
|
/* Get ready to modify the registers array. On machines which store
|
1367 |
|
|
individual registers, this doesn't need to do anything. On machines
|
1368 |
|
|
which store all the registers in one fell swoop, this makes sure
|
1369 |
|
|
that registers contains all the registers from the program being
|
1370 |
|
|
debugged. */
|
1371 |
|
|
|
1372 |
|
|
static void
|
1373 |
|
|
monitor_prepare_to_store (struct regcache *regcache)
|
1374 |
|
|
{
|
1375 |
|
|
/* Do nothing, since we can store individual regs */
|
1376 |
|
|
}
|
1377 |
|
|
|
1378 |
|
|
static void
|
1379 |
|
|
monitor_files_info (struct target_ops *ops)
|
1380 |
|
|
{
|
1381 |
|
|
printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
|
1382 |
|
|
}
|
1383 |
|
|
|
1384 |
|
|
static int
|
1385 |
|
|
monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
|
1386 |
|
|
{
|
1387 |
|
|
unsigned int val, hostval;
|
1388 |
|
|
char *cmd;
|
1389 |
|
|
int i;
|
1390 |
|
|
|
1391 |
|
|
monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
|
1392 |
|
|
|
1393 |
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
1394 |
|
|
memaddr = gdbarch_addr_bits_remove (current_gdbarch, memaddr);
|
1395 |
|
|
|
1396 |
|
|
/* Use memory fill command for leading 0 bytes. */
|
1397 |
|
|
|
1398 |
|
|
if (current_monitor->fill)
|
1399 |
|
|
{
|
1400 |
|
|
for (i = 0; i < len; i++)
|
1401 |
|
|
if (myaddr[i] != 0)
|
1402 |
|
|
break;
|
1403 |
|
|
|
1404 |
|
|
if (i > 4) /* More than 4 zeros is worth doing */
|
1405 |
|
|
{
|
1406 |
|
|
monitor_debug ("MON FILL %d\n", i);
|
1407 |
|
|
if (current_monitor->flags & MO_FILL_USES_ADDR)
|
1408 |
|
|
monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
|
1409 |
|
|
else
|
1410 |
|
|
monitor_printf (current_monitor->fill, memaddr, i, 0);
|
1411 |
|
|
|
1412 |
|
|
monitor_expect_prompt (NULL, 0);
|
1413 |
|
|
|
1414 |
|
|
return i;
|
1415 |
|
|
}
|
1416 |
|
|
}
|
1417 |
|
|
|
1418 |
|
|
#if 0
|
1419 |
|
|
/* Can't actually use long longs if VAL is an int (nice idea, though). */
|
1420 |
|
|
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
|
1421 |
|
|
{
|
1422 |
|
|
len = 8;
|
1423 |
|
|
cmd = current_monitor->setmem.cmdll;
|
1424 |
|
|
}
|
1425 |
|
|
else
|
1426 |
|
|
#endif
|
1427 |
|
|
if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
|
1428 |
|
|
{
|
1429 |
|
|
len = 4;
|
1430 |
|
|
cmd = current_monitor->setmem.cmdl;
|
1431 |
|
|
}
|
1432 |
|
|
else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
|
1433 |
|
|
{
|
1434 |
|
|
len = 2;
|
1435 |
|
|
cmd = current_monitor->setmem.cmdw;
|
1436 |
|
|
}
|
1437 |
|
|
else
|
1438 |
|
|
{
|
1439 |
|
|
len = 1;
|
1440 |
|
|
cmd = current_monitor->setmem.cmdb;
|
1441 |
|
|
}
|
1442 |
|
|
|
1443 |
|
|
val = extract_unsigned_integer (myaddr, len);
|
1444 |
|
|
|
1445 |
|
|
if (len == 4)
|
1446 |
|
|
{
|
1447 |
|
|
hostval = *(unsigned int *) myaddr;
|
1448 |
|
|
monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
|
1449 |
|
|
}
|
1450 |
|
|
|
1451 |
|
|
|
1452 |
|
|
if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
|
1453 |
|
|
monitor_printf_noecho (cmd, memaddr, val);
|
1454 |
|
|
else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
|
1455 |
|
|
{
|
1456 |
|
|
|
1457 |
|
|
monitor_printf_noecho (cmd, memaddr);
|
1458 |
|
|
|
1459 |
|
|
if (current_monitor->setmem.resp_delim)
|
1460 |
|
|
{
|
1461 |
|
|
monitor_debug ("EXP setmem.resp_delim");
|
1462 |
|
|
monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0);
|
1463 |
|
|
monitor_printf ("%x\r", val);
|
1464 |
|
|
}
|
1465 |
|
|
if (current_monitor->setmem.term)
|
1466 |
|
|
{
|
1467 |
|
|
monitor_debug ("EXP setmem.term");
|
1468 |
|
|
monitor_expect (current_monitor->setmem.term, NULL, 0);
|
1469 |
|
|
monitor_printf ("%x\r", val);
|
1470 |
|
|
}
|
1471 |
|
|
if (current_monitor->setmem.term_cmd)
|
1472 |
|
|
{ /* Emit this to get out of the memory editing state */
|
1473 |
|
|
monitor_printf ("%s", current_monitor->setmem.term_cmd);
|
1474 |
|
|
/* Drop through to expecting a prompt */
|
1475 |
|
|
}
|
1476 |
|
|
}
|
1477 |
|
|
else
|
1478 |
|
|
monitor_printf (cmd, memaddr, val);
|
1479 |
|
|
|
1480 |
|
|
monitor_expect_prompt (NULL, 0);
|
1481 |
|
|
|
1482 |
|
|
return len;
|
1483 |
|
|
}
|
1484 |
|
|
|
1485 |
|
|
|
1486 |
|
|
static int
|
1487 |
|
|
monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
|
1488 |
|
|
{
|
1489 |
|
|
unsigned char val;
|
1490 |
|
|
int written = 0;
|
1491 |
|
|
if (len == 0)
|
1492 |
|
|
return 0;
|
1493 |
|
|
/* Enter the sub mode */
|
1494 |
|
|
monitor_printf (current_monitor->setmem.cmdb, memaddr);
|
1495 |
|
|
monitor_expect_prompt (NULL, 0);
|
1496 |
|
|
while (len)
|
1497 |
|
|
{
|
1498 |
|
|
val = *myaddr;
|
1499 |
|
|
monitor_printf ("%x\r", val);
|
1500 |
|
|
myaddr++;
|
1501 |
|
|
memaddr++;
|
1502 |
|
|
written++;
|
1503 |
|
|
/* If we wanted to, here we could validate the address */
|
1504 |
|
|
monitor_expect_prompt (NULL, 0);
|
1505 |
|
|
len--;
|
1506 |
|
|
}
|
1507 |
|
|
/* Now exit the sub mode */
|
1508 |
|
|
monitor_printf (current_monitor->getreg.term_cmd);
|
1509 |
|
|
monitor_expect_prompt (NULL, 0);
|
1510 |
|
|
return written;
|
1511 |
|
|
}
|
1512 |
|
|
|
1513 |
|
|
|
1514 |
|
|
static void
|
1515 |
|
|
longlongendswap (unsigned char *a)
|
1516 |
|
|
{
|
1517 |
|
|
int i, j;
|
1518 |
|
|
unsigned char x;
|
1519 |
|
|
i = 0;
|
1520 |
|
|
j = 7;
|
1521 |
|
|
while (i < 4)
|
1522 |
|
|
{
|
1523 |
|
|
x = *(a + i);
|
1524 |
|
|
*(a + i) = *(a + j);
|
1525 |
|
|
*(a + j) = x;
|
1526 |
|
|
i++, j--;
|
1527 |
|
|
}
|
1528 |
|
|
}
|
1529 |
|
|
/* Format 32 chars of long long value, advance the pointer */
|
1530 |
|
|
static char *hexlate = "0123456789abcdef";
|
1531 |
|
|
static char *
|
1532 |
|
|
longlong_hexchars (unsigned long long value,
|
1533 |
|
|
char *outbuff)
|
1534 |
|
|
{
|
1535 |
|
|
if (value == 0)
|
1536 |
|
|
{
|
1537 |
|
|
*outbuff++ = '0';
|
1538 |
|
|
return outbuff;
|
1539 |
|
|
}
|
1540 |
|
|
else
|
1541 |
|
|
{
|
1542 |
|
|
static unsigned char disbuf[8]; /* disassembly buffer */
|
1543 |
|
|
unsigned char *scan, *limit; /* loop controls */
|
1544 |
|
|
unsigned char c, nib;
|
1545 |
|
|
int leadzero = 1;
|
1546 |
|
|
scan = disbuf;
|
1547 |
|
|
limit = scan + 8;
|
1548 |
|
|
{
|
1549 |
|
|
unsigned long long *dp;
|
1550 |
|
|
dp = (unsigned long long *) scan;
|
1551 |
|
|
*dp = value;
|
1552 |
|
|
}
|
1553 |
|
|
longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
|
1554 |
|
|
while (scan < limit)
|
1555 |
|
|
{
|
1556 |
|
|
c = *scan++; /* a byte of our long long value */
|
1557 |
|
|
if (leadzero)
|
1558 |
|
|
{
|
1559 |
|
|
if (c == 0)
|
1560 |
|
|
continue;
|
1561 |
|
|
else
|
1562 |
|
|
leadzero = 0; /* henceforth we print even zeroes */
|
1563 |
|
|
}
|
1564 |
|
|
nib = c >> 4; /* high nibble bits */
|
1565 |
|
|
*outbuff++ = hexlate[nib];
|
1566 |
|
|
nib = c & 0x0f; /* low nibble bits */
|
1567 |
|
|
*outbuff++ = hexlate[nib];
|
1568 |
|
|
}
|
1569 |
|
|
return outbuff;
|
1570 |
|
|
}
|
1571 |
|
|
} /* longlong_hexchars */
|
1572 |
|
|
|
1573 |
|
|
|
1574 |
|
|
|
1575 |
|
|
/* I am only going to call this when writing virtual byte streams.
|
1576 |
|
|
Which possably entails endian conversions
|
1577 |
|
|
*/
|
1578 |
|
|
static int
|
1579 |
|
|
monitor_write_memory_longlongs (CORE_ADDR memaddr, char *myaddr, int len)
|
1580 |
|
|
{
|
1581 |
|
|
static char hexstage[20]; /* At least 16 digits required, plus null */
|
1582 |
|
|
char *endstring;
|
1583 |
|
|
long long *llptr;
|
1584 |
|
|
long long value;
|
1585 |
|
|
int written = 0;
|
1586 |
|
|
llptr = (unsigned long long *) myaddr;
|
1587 |
|
|
if (len == 0)
|
1588 |
|
|
return 0;
|
1589 |
|
|
monitor_printf (current_monitor->setmem.cmdll, memaddr);
|
1590 |
|
|
monitor_expect_prompt (NULL, 0);
|
1591 |
|
|
while (len >= 8)
|
1592 |
|
|
{
|
1593 |
|
|
value = *llptr;
|
1594 |
|
|
endstring = longlong_hexchars (*llptr, hexstage);
|
1595 |
|
|
*endstring = '\0'; /* NUll terminate for printf */
|
1596 |
|
|
monitor_printf ("%s\r", hexstage);
|
1597 |
|
|
llptr++;
|
1598 |
|
|
memaddr += 8;
|
1599 |
|
|
written += 8;
|
1600 |
|
|
/* If we wanted to, here we could validate the address */
|
1601 |
|
|
monitor_expect_prompt (NULL, 0);
|
1602 |
|
|
len -= 8;
|
1603 |
|
|
}
|
1604 |
|
|
/* Now exit the sub mode */
|
1605 |
|
|
monitor_printf (current_monitor->getreg.term_cmd);
|
1606 |
|
|
monitor_expect_prompt (NULL, 0);
|
1607 |
|
|
return written;
|
1608 |
|
|
} /* */
|
1609 |
|
|
|
1610 |
|
|
|
1611 |
|
|
|
1612 |
|
|
/* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
|
1613 |
|
|
/* This is for the large blocks of memory which may occur in downloading.
|
1614 |
|
|
And for monitors which use interactive entry,
|
1615 |
|
|
And for monitors which do not have other downloading methods.
|
1616 |
|
|
Without this, we will end up calling monitor_write_memory many times
|
1617 |
|
|
and do the entry and exit of the sub mode many times
|
1618 |
|
|
This currently assumes...
|
1619 |
|
|
MO_SETMEM_INTERACTIVE
|
1620 |
|
|
! MO_NO_ECHO_ON_SETMEM
|
1621 |
|
|
To use this, the you have to patch the monitor_cmds block with
|
1622 |
|
|
this function. Otherwise, its not tuned up for use by all
|
1623 |
|
|
monitor variations.
|
1624 |
|
|
*/
|
1625 |
|
|
|
1626 |
|
|
static int
|
1627 |
|
|
monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
|
1628 |
|
|
{
|
1629 |
|
|
int written;
|
1630 |
|
|
written = 0;
|
1631 |
|
|
/* FIXME: This would be a good place to put the zero test */
|
1632 |
|
|
#if 1
|
1633 |
|
|
if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
|
1634 |
|
|
{
|
1635 |
|
|
return monitor_write_memory_longlongs (memaddr, myaddr, len);
|
1636 |
|
|
}
|
1637 |
|
|
#endif
|
1638 |
|
|
written = monitor_write_memory_bytes (memaddr, myaddr, len);
|
1639 |
|
|
return written;
|
1640 |
|
|
}
|
1641 |
|
|
|
1642 |
|
|
/* This is an alternate form of monitor_read_memory which is used for monitors
|
1643 |
|
|
which can only read a single byte/word/etc. at a time. */
|
1644 |
|
|
|
1645 |
|
|
static int
|
1646 |
|
|
monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
|
1647 |
|
|
{
|
1648 |
|
|
unsigned int val;
|
1649 |
|
|
char membuf[sizeof (int) * 2 + 1];
|
1650 |
|
|
char *p;
|
1651 |
|
|
char *cmd;
|
1652 |
|
|
|
1653 |
|
|
monitor_debug ("MON read single\n");
|
1654 |
|
|
#if 0
|
1655 |
|
|
/* Can't actually use long longs (nice idea, though). In fact, the
|
1656 |
|
|
call to strtoul below will fail if it tries to convert a value
|
1657 |
|
|
that's too big to fit in a long. */
|
1658 |
|
|
if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
|
1659 |
|
|
{
|
1660 |
|
|
len = 8;
|
1661 |
|
|
cmd = current_monitor->getmem.cmdll;
|
1662 |
|
|
}
|
1663 |
|
|
else
|
1664 |
|
|
#endif
|
1665 |
|
|
if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
|
1666 |
|
|
{
|
1667 |
|
|
len = 4;
|
1668 |
|
|
cmd = current_monitor->getmem.cmdl;
|
1669 |
|
|
}
|
1670 |
|
|
else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
|
1671 |
|
|
{
|
1672 |
|
|
len = 2;
|
1673 |
|
|
cmd = current_monitor->getmem.cmdw;
|
1674 |
|
|
}
|
1675 |
|
|
else
|
1676 |
|
|
{
|
1677 |
|
|
len = 1;
|
1678 |
|
|
cmd = current_monitor->getmem.cmdb;
|
1679 |
|
|
}
|
1680 |
|
|
|
1681 |
|
|
/* Send the examine command. */
|
1682 |
|
|
|
1683 |
|
|
monitor_printf (cmd, memaddr);
|
1684 |
|
|
|
1685 |
|
|
/* If RESP_DELIM is specified, we search for that as a leading
|
1686 |
|
|
delimiter for the memory value. Otherwise, we just start
|
1687 |
|
|
searching from the start of the buf. */
|
1688 |
|
|
|
1689 |
|
|
if (current_monitor->getmem.resp_delim)
|
1690 |
|
|
{
|
1691 |
|
|
monitor_debug ("EXP getmem.resp_delim\n");
|
1692 |
|
|
monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
|
1693 |
|
|
}
|
1694 |
|
|
|
1695 |
|
|
/* Now, read the appropriate number of hex digits for this loc,
|
1696 |
|
|
skipping spaces. */
|
1697 |
|
|
|
1698 |
|
|
/* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
|
1699 |
|
|
if (current_monitor->flags & MO_HEX_PREFIX)
|
1700 |
|
|
{
|
1701 |
|
|
int c;
|
1702 |
|
|
|
1703 |
|
|
c = readchar (timeout);
|
1704 |
|
|
while (c == ' ')
|
1705 |
|
|
c = readchar (timeout);
|
1706 |
|
|
if ((c == '0') && ((c = readchar (timeout)) == 'x'))
|
1707 |
|
|
;
|
1708 |
|
|
else
|
1709 |
|
|
monitor_error ("monitor_read_memory_single",
|
1710 |
|
|
"bad response from monitor",
|
1711 |
|
|
memaddr, 0, NULL, 0);
|
1712 |
|
|
}
|
1713 |
|
|
|
1714 |
|
|
{
|
1715 |
|
|
int i;
|
1716 |
|
|
for (i = 0; i < len * 2; i++)
|
1717 |
|
|
{
|
1718 |
|
|
int c;
|
1719 |
|
|
|
1720 |
|
|
while (1)
|
1721 |
|
|
{
|
1722 |
|
|
c = readchar (timeout);
|
1723 |
|
|
if (isxdigit (c))
|
1724 |
|
|
break;
|
1725 |
|
|
if (c == ' ')
|
1726 |
|
|
continue;
|
1727 |
|
|
|
1728 |
|
|
monitor_error ("monitor_read_memory_single",
|
1729 |
|
|
"bad response from monitor",
|
1730 |
|
|
memaddr, i, membuf, 0);
|
1731 |
|
|
}
|
1732 |
|
|
membuf[i] = c;
|
1733 |
|
|
}
|
1734 |
|
|
membuf[i] = '\000'; /* terminate the number */
|
1735 |
|
|
}
|
1736 |
|
|
|
1737 |
|
|
/* If TERM is present, we wait for that to show up. Also, (if TERM is
|
1738 |
|
|
present), we will send TERM_CMD if that is present. In any case, we collect
|
1739 |
|
|
all of the output into buf, and then wait for the normal prompt. */
|
1740 |
|
|
|
1741 |
|
|
if (current_monitor->getmem.term)
|
1742 |
|
|
{
|
1743 |
|
|
monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
|
1744 |
|
|
|
1745 |
|
|
if (current_monitor->getmem.term_cmd)
|
1746 |
|
|
{
|
1747 |
|
|
monitor_printf (current_monitor->getmem.term_cmd);
|
1748 |
|
|
monitor_expect_prompt (NULL, 0);
|
1749 |
|
|
}
|
1750 |
|
|
}
|
1751 |
|
|
else
|
1752 |
|
|
monitor_expect_prompt (NULL, 0); /* get response */
|
1753 |
|
|
|
1754 |
|
|
p = membuf;
|
1755 |
|
|
val = strtoul (membuf, &p, 16);
|
1756 |
|
|
|
1757 |
|
|
if (val == 0 && membuf == p)
|
1758 |
|
|
monitor_error ("monitor_read_memory_single",
|
1759 |
|
|
"bad value from monitor",
|
1760 |
|
|
memaddr, 0, membuf, 0);
|
1761 |
|
|
|
1762 |
|
|
/* supply register stores in target byte order, so swap here */
|
1763 |
|
|
|
1764 |
|
|
store_unsigned_integer (myaddr, len, val);
|
1765 |
|
|
|
1766 |
|
|
return len;
|
1767 |
|
|
}
|
1768 |
|
|
|
1769 |
|
|
/* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
|
1770 |
|
|
memory at MEMADDR. Returns length moved. Currently, we do no more
|
1771 |
|
|
than 16 bytes at a time. */
|
1772 |
|
|
|
1773 |
|
|
static int
|
1774 |
|
|
monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
|
1775 |
|
|
{
|
1776 |
|
|
unsigned int val;
|
1777 |
|
|
char buf[512];
|
1778 |
|
|
char *p, *p1;
|
1779 |
|
|
int resp_len;
|
1780 |
|
|
int i;
|
1781 |
|
|
CORE_ADDR dumpaddr;
|
1782 |
|
|
|
1783 |
|
|
if (len <= 0)
|
1784 |
|
|
{
|
1785 |
|
|
monitor_debug ("Zero length call to monitor_read_memory\n");
|
1786 |
|
|
return 0;
|
1787 |
|
|
}
|
1788 |
|
|
|
1789 |
|
|
monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
|
1790 |
|
|
paddr_nz (memaddr), (long) myaddr, len);
|
1791 |
|
|
|
1792 |
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
1793 |
|
|
memaddr = gdbarch_addr_bits_remove (current_gdbarch, memaddr);
|
1794 |
|
|
|
1795 |
|
|
if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
|
1796 |
|
|
return monitor_read_memory_single (memaddr, myaddr, len);
|
1797 |
|
|
|
1798 |
|
|
len = min (len, 16);
|
1799 |
|
|
|
1800 |
|
|
/* Some dumpers align the first data with the preceeding 16
|
1801 |
|
|
byte boundary. Some print blanks and start at the
|
1802 |
|
|
requested boundary. EXACT_DUMPADDR
|
1803 |
|
|
*/
|
1804 |
|
|
|
1805 |
|
|
dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
|
1806 |
|
|
? memaddr : memaddr & ~0x0f;
|
1807 |
|
|
|
1808 |
|
|
/* See if xfer would cross a 16 byte boundary. If so, clip it. */
|
1809 |
|
|
if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
|
1810 |
|
|
len = ((memaddr + len) & ~0xf) - memaddr;
|
1811 |
|
|
|
1812 |
|
|
/* send the memory examine command */
|
1813 |
|
|
|
1814 |
|
|
if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
|
1815 |
|
|
monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
|
1816 |
|
|
else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
|
1817 |
|
|
monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
|
1818 |
|
|
else
|
1819 |
|
|
monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
|
1820 |
|
|
|
1821 |
|
|
/* If TERM is present, we wait for that to show up. Also, (if TERM
|
1822 |
|
|
is present), we will send TERM_CMD if that is present. In any
|
1823 |
|
|
case, we collect all of the output into buf, and then wait for
|
1824 |
|
|
the normal prompt. */
|
1825 |
|
|
|
1826 |
|
|
if (current_monitor->getmem.term)
|
1827 |
|
|
{
|
1828 |
|
|
resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
|
1829 |
|
|
|
1830 |
|
|
if (resp_len <= 0)
|
1831 |
|
|
monitor_error ("monitor_read_memory",
|
1832 |
|
|
"excessive response from monitor",
|
1833 |
|
|
memaddr, resp_len, buf, 0);
|
1834 |
|
|
|
1835 |
|
|
if (current_monitor->getmem.term_cmd)
|
1836 |
|
|
{
|
1837 |
|
|
serial_write (monitor_desc, current_monitor->getmem.term_cmd,
|
1838 |
|
|
strlen (current_monitor->getmem.term_cmd));
|
1839 |
|
|
monitor_expect_prompt (NULL, 0);
|
1840 |
|
|
}
|
1841 |
|
|
}
|
1842 |
|
|
else
|
1843 |
|
|
resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
|
1844 |
|
|
|
1845 |
|
|
p = buf;
|
1846 |
|
|
|
1847 |
|
|
/* If RESP_DELIM is specified, we search for that as a leading
|
1848 |
|
|
delimiter for the values. Otherwise, we just start searching
|
1849 |
|
|
from the start of the buf. */
|
1850 |
|
|
|
1851 |
|
|
if (current_monitor->getmem.resp_delim)
|
1852 |
|
|
{
|
1853 |
|
|
int retval, tmp;
|
1854 |
|
|
struct re_registers resp_strings;
|
1855 |
|
|
monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
|
1856 |
|
|
|
1857 |
|
|
memset (&resp_strings, 0, sizeof (struct re_registers));
|
1858 |
|
|
tmp = strlen (p);
|
1859 |
|
|
retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
|
1860 |
|
|
&resp_strings);
|
1861 |
|
|
|
1862 |
|
|
if (retval < 0)
|
1863 |
|
|
monitor_error ("monitor_read_memory",
|
1864 |
|
|
"bad response from monitor",
|
1865 |
|
|
memaddr, resp_len, buf, 0);
|
1866 |
|
|
|
1867 |
|
|
p += resp_strings.end[0];
|
1868 |
|
|
#if 0
|
1869 |
|
|
p = strstr (p, current_monitor->getmem.resp_delim);
|
1870 |
|
|
if (!p)
|
1871 |
|
|
monitor_error ("monitor_read_memory",
|
1872 |
|
|
"bad response from monitor",
|
1873 |
|
|
memaddr, resp_len, buf, 0);
|
1874 |
|
|
p += strlen (current_monitor->getmem.resp_delim);
|
1875 |
|
|
#endif
|
1876 |
|
|
}
|
1877 |
|
|
monitor_debug ("MON scanning %d ,%lx '%s'\n", len, (long) p, p);
|
1878 |
|
|
if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
|
1879 |
|
|
{
|
1880 |
|
|
char c;
|
1881 |
|
|
int fetched = 0;
|
1882 |
|
|
i = len;
|
1883 |
|
|
c = *p;
|
1884 |
|
|
|
1885 |
|
|
|
1886 |
|
|
while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
|
1887 |
|
|
{
|
1888 |
|
|
if (isxdigit (c))
|
1889 |
|
|
{
|
1890 |
|
|
if ((dumpaddr >= memaddr) && (i > 0))
|
1891 |
|
|
{
|
1892 |
|
|
val = fromhex (c) * 16 + fromhex (*(p + 1));
|
1893 |
|
|
*myaddr++ = val;
|
1894 |
|
|
if (monitor_debug_p || remote_debug)
|
1895 |
|
|
fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
|
1896 |
|
|
--i;
|
1897 |
|
|
fetched++;
|
1898 |
|
|
}
|
1899 |
|
|
++dumpaddr;
|
1900 |
|
|
++p;
|
1901 |
|
|
}
|
1902 |
|
|
++p; /* skip a blank or other non hex char */
|
1903 |
|
|
c = *p;
|
1904 |
|
|
}
|
1905 |
|
|
if (fetched == 0)
|
1906 |
|
|
error (_("Failed to read via monitor"));
|
1907 |
|
|
if (monitor_debug_p || remote_debug)
|
1908 |
|
|
fprintf_unfiltered (gdb_stdlog, "\n");
|
1909 |
|
|
return fetched; /* Return the number of bytes actually read */
|
1910 |
|
|
}
|
1911 |
|
|
monitor_debug ("MON scanning bytes\n");
|
1912 |
|
|
|
1913 |
|
|
for (i = len; i > 0; i--)
|
1914 |
|
|
{
|
1915 |
|
|
/* Skip non-hex chars, but bomb on end of string and newlines */
|
1916 |
|
|
|
1917 |
|
|
while (1)
|
1918 |
|
|
{
|
1919 |
|
|
if (isxdigit (*p))
|
1920 |
|
|
break;
|
1921 |
|
|
|
1922 |
|
|
if (*p == '\000' || *p == '\n' || *p == '\r')
|
1923 |
|
|
monitor_error ("monitor_read_memory",
|
1924 |
|
|
"badly terminated response from monitor",
|
1925 |
|
|
memaddr, resp_len, buf, 0);
|
1926 |
|
|
p++;
|
1927 |
|
|
}
|
1928 |
|
|
|
1929 |
|
|
val = strtoul (p, &p1, 16);
|
1930 |
|
|
|
1931 |
|
|
if (val == 0 && p == p1)
|
1932 |
|
|
monitor_error ("monitor_read_memory",
|
1933 |
|
|
"bad value from monitor",
|
1934 |
|
|
memaddr, resp_len, buf, 0);
|
1935 |
|
|
|
1936 |
|
|
*myaddr++ = val;
|
1937 |
|
|
|
1938 |
|
|
if (i == 1)
|
1939 |
|
|
break;
|
1940 |
|
|
|
1941 |
|
|
p = p1;
|
1942 |
|
|
}
|
1943 |
|
|
|
1944 |
|
|
return len;
|
1945 |
|
|
}
|
1946 |
|
|
|
1947 |
|
|
/* Transfer LEN bytes between target address MEMADDR and GDB address
|
1948 |
|
|
MYADDR. Returns 0 for success, errno code for failure. TARGET is
|
1949 |
|
|
unused. */
|
1950 |
|
|
|
1951 |
|
|
static int
|
1952 |
|
|
monitor_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
|
1953 |
|
|
struct mem_attrib *attrib, struct target_ops *target)
|
1954 |
|
|
{
|
1955 |
|
|
int res;
|
1956 |
|
|
|
1957 |
|
|
if (write)
|
1958 |
|
|
{
|
1959 |
|
|
if (current_monitor->flags & MO_HAS_BLOCKWRITES)
|
1960 |
|
|
res = monitor_write_memory_block(memaddr, myaddr, len);
|
1961 |
|
|
else
|
1962 |
|
|
res = monitor_write_memory(memaddr, myaddr, len);
|
1963 |
|
|
}
|
1964 |
|
|
else
|
1965 |
|
|
{
|
1966 |
|
|
res = monitor_read_memory(memaddr, myaddr, len);
|
1967 |
|
|
}
|
1968 |
|
|
|
1969 |
|
|
return res;
|
1970 |
|
|
}
|
1971 |
|
|
|
1972 |
|
|
static void
|
1973 |
|
|
monitor_kill (void)
|
1974 |
|
|
{
|
1975 |
|
|
return; /* ignore attempts to kill target system */
|
1976 |
|
|
}
|
1977 |
|
|
|
1978 |
|
|
/* All we actually do is set the PC to the start address of exec_bfd. */
|
1979 |
|
|
|
1980 |
|
|
static void
|
1981 |
|
|
monitor_create_inferior (char *exec_file, char *args, char **env,
|
1982 |
|
|
int from_tty)
|
1983 |
|
|
{
|
1984 |
|
|
if (args && (*args != '\000'))
|
1985 |
|
|
error (_("Args are not supported by the monitor."));
|
1986 |
|
|
|
1987 |
|
|
first_time = 1;
|
1988 |
|
|
clear_proceed_status ();
|
1989 |
|
|
write_pc (bfd_get_start_address (exec_bfd));
|
1990 |
|
|
}
|
1991 |
|
|
|
1992 |
|
|
/* Clean up when a program exits.
|
1993 |
|
|
The program actually lives on in the remote processor's RAM, and may be
|
1994 |
|
|
run again without a download. Don't leave it full of breakpoint
|
1995 |
|
|
instructions. */
|
1996 |
|
|
|
1997 |
|
|
static void
|
1998 |
|
|
monitor_mourn_inferior (void)
|
1999 |
|
|
{
|
2000 |
|
|
unpush_target (targ_ops);
|
2001 |
|
|
generic_mourn_inferior (); /* Do all the proper things now */
|
2002 |
|
|
}
|
2003 |
|
|
|
2004 |
|
|
/* Tell the monitor to add a breakpoint. */
|
2005 |
|
|
|
2006 |
|
|
static int
|
2007 |
|
|
monitor_insert_breakpoint (struct bp_target_info *bp_tgt)
|
2008 |
|
|
{
|
2009 |
|
|
CORE_ADDR addr = bp_tgt->placed_address;
|
2010 |
|
|
int i;
|
2011 |
|
|
const unsigned char *bp;
|
2012 |
|
|
int bplen;
|
2013 |
|
|
|
2014 |
|
|
monitor_debug ("MON inst bkpt %s\n", paddr (addr));
|
2015 |
|
|
if (current_monitor->set_break == NULL)
|
2016 |
|
|
error (_("No set_break defined for this monitor"));
|
2017 |
|
|
|
2018 |
|
|
if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
|
2019 |
|
|
addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
|
2020 |
|
|
|
2021 |
|
|
/* Determine appropriate breakpoint size for this address. */
|
2022 |
|
|
bp = gdbarch_breakpoint_from_pc (current_gdbarch, &addr, &bplen);
|
2023 |
|
|
bp_tgt->placed_address = addr;
|
2024 |
|
|
bp_tgt->placed_size = bplen;
|
2025 |
|
|
|
2026 |
|
|
for (i = 0; i < current_monitor->num_breakpoints; i++)
|
2027 |
|
|
{
|
2028 |
|
|
if (breakaddr[i] == 0)
|
2029 |
|
|
{
|
2030 |
|
|
breakaddr[i] = addr;
|
2031 |
|
|
monitor_printf (current_monitor->set_break, addr);
|
2032 |
|
|
monitor_expect_prompt (NULL, 0);
|
2033 |
|
|
return 0;
|
2034 |
|
|
}
|
2035 |
|
|
}
|
2036 |
|
|
|
2037 |
|
|
error (_("Too many breakpoints (> %d) for monitor."), current_monitor->num_breakpoints);
|
2038 |
|
|
}
|
2039 |
|
|
|
2040 |
|
|
/* Tell the monitor to remove a breakpoint. */
|
2041 |
|
|
|
2042 |
|
|
static int
|
2043 |
|
|
monitor_remove_breakpoint (struct bp_target_info *bp_tgt)
|
2044 |
|
|
{
|
2045 |
|
|
CORE_ADDR addr = bp_tgt->placed_address;
|
2046 |
|
|
int i;
|
2047 |
|
|
|
2048 |
|
|
monitor_debug ("MON rmbkpt %s\n", paddr (addr));
|
2049 |
|
|
if (current_monitor->clr_break == NULL)
|
2050 |
|
|
error (_("No clr_break defined for this monitor"));
|
2051 |
|
|
|
2052 |
|
|
for (i = 0; i < current_monitor->num_breakpoints; i++)
|
2053 |
|
|
{
|
2054 |
|
|
if (breakaddr[i] == addr)
|
2055 |
|
|
{
|
2056 |
|
|
breakaddr[i] = 0;
|
2057 |
|
|
/* some monitors remove breakpoints based on the address */
|
2058 |
|
|
if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
|
2059 |
|
|
monitor_printf (current_monitor->clr_break, addr);
|
2060 |
|
|
else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
|
2061 |
|
|
monitor_printf (current_monitor->clr_break, i + 1);
|
2062 |
|
|
else
|
2063 |
|
|
monitor_printf (current_monitor->clr_break, i);
|
2064 |
|
|
monitor_expect_prompt (NULL, 0);
|
2065 |
|
|
return 0;
|
2066 |
|
|
}
|
2067 |
|
|
}
|
2068 |
|
|
fprintf_unfiltered (gdb_stderr,
|
2069 |
|
|
"Can't find breakpoint associated with 0x%s\n",
|
2070 |
|
|
paddr_nz (addr));
|
2071 |
|
|
return 1;
|
2072 |
|
|
}
|
2073 |
|
|
|
2074 |
|
|
/* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
|
2075 |
|
|
an S-record. Return non-zero if the ACK is received properly. */
|
2076 |
|
|
|
2077 |
|
|
static int
|
2078 |
|
|
monitor_wait_srec_ack (void)
|
2079 |
|
|
{
|
2080 |
|
|
int ch;
|
2081 |
|
|
|
2082 |
|
|
if (current_monitor->flags & MO_SREC_ACK_PLUS)
|
2083 |
|
|
{
|
2084 |
|
|
return (readchar (timeout) == '+');
|
2085 |
|
|
}
|
2086 |
|
|
else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
|
2087 |
|
|
{
|
2088 |
|
|
/* Eat two backspaces, a "rotating" char (|/-\), and a space. */
|
2089 |
|
|
if ((ch = readchar (1)) < 0)
|
2090 |
|
|
return 0;
|
2091 |
|
|
if ((ch = readchar (1)) < 0)
|
2092 |
|
|
return 0;
|
2093 |
|
|
if ((ch = readchar (1)) < 0)
|
2094 |
|
|
return 0;
|
2095 |
|
|
if ((ch = readchar (1)) < 0)
|
2096 |
|
|
return 0;
|
2097 |
|
|
}
|
2098 |
|
|
return 1;
|
2099 |
|
|
}
|
2100 |
|
|
|
2101 |
|
|
/* monitor_load -- download a file. */
|
2102 |
|
|
|
2103 |
|
|
static void
|
2104 |
|
|
monitor_load (char *file, int from_tty)
|
2105 |
|
|
{
|
2106 |
|
|
monitor_debug ("MON load\n");
|
2107 |
|
|
|
2108 |
|
|
if (current_monitor->load_routine)
|
2109 |
|
|
current_monitor->load_routine (monitor_desc, file, hashmark);
|
2110 |
|
|
else
|
2111 |
|
|
{ /* The default is ascii S-records */
|
2112 |
|
|
int n;
|
2113 |
|
|
unsigned long load_offset;
|
2114 |
|
|
char buf[128];
|
2115 |
|
|
|
2116 |
|
|
/* enable user to specify address for downloading as 2nd arg to load */
|
2117 |
|
|
n = sscanf (file, "%s 0x%lx", buf, &load_offset);
|
2118 |
|
|
if (n > 1)
|
2119 |
|
|
file = buf;
|
2120 |
|
|
else
|
2121 |
|
|
load_offset = 0;
|
2122 |
|
|
|
2123 |
|
|
monitor_printf (current_monitor->load);
|
2124 |
|
|
if (current_monitor->loadresp)
|
2125 |
|
|
monitor_expect (current_monitor->loadresp, NULL, 0);
|
2126 |
|
|
|
2127 |
|
|
load_srec (monitor_desc, file, (bfd_vma) load_offset,
|
2128 |
|
|
32, SREC_ALL, hashmark,
|
2129 |
|
|
current_monitor->flags & MO_SREC_ACK ?
|
2130 |
|
|
monitor_wait_srec_ack : NULL);
|
2131 |
|
|
|
2132 |
|
|
monitor_expect_prompt (NULL, 0);
|
2133 |
|
|
}
|
2134 |
|
|
|
2135 |
|
|
/* Finally, make the PC point at the start address */
|
2136 |
|
|
if (exec_bfd)
|
2137 |
|
|
write_pc (bfd_get_start_address (exec_bfd));
|
2138 |
|
|
|
2139 |
|
|
/* There used to be code here which would clear inferior_ptid and
|
2140 |
|
|
call clear_symtab_users. None of that should be necessary:
|
2141 |
|
|
monitor targets should behave like remote protocol targets, and
|
2142 |
|
|
since generic_load does none of those things, this function
|
2143 |
|
|
shouldn't either.
|
2144 |
|
|
|
2145 |
|
|
Furthermore, clearing inferior_ptid is *incorrect*. After doing
|
2146 |
|
|
a load, we still have a valid connection to the monitor, with a
|
2147 |
|
|
live processor state to fiddle with. The user can type
|
2148 |
|
|
`continue' or `jump *start' and make the program run. If they do
|
2149 |
|
|
these things, however, GDB will be talking to a running program
|
2150 |
|
|
while inferior_ptid is null_ptid; this makes things like
|
2151 |
|
|
reinit_frame_cache very confused. */
|
2152 |
|
|
}
|
2153 |
|
|
|
2154 |
|
|
static void
|
2155 |
|
|
monitor_stop (void)
|
2156 |
|
|
{
|
2157 |
|
|
monitor_debug ("MON stop\n");
|
2158 |
|
|
if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
|
2159 |
|
|
serial_send_break (monitor_desc);
|
2160 |
|
|
if (current_monitor->stop)
|
2161 |
|
|
monitor_printf_noecho (current_monitor->stop);
|
2162 |
|
|
}
|
2163 |
|
|
|
2164 |
|
|
/* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
|
2165 |
|
|
in OUTPUT until the prompt is seen. FIXME: We read the characters
|
2166 |
|
|
ourseleves here cause of a nasty echo. */
|
2167 |
|
|
|
2168 |
|
|
static void
|
2169 |
|
|
monitor_rcmd (char *command,
|
2170 |
|
|
struct ui_file *outbuf)
|
2171 |
|
|
{
|
2172 |
|
|
char *p;
|
2173 |
|
|
int resp_len;
|
2174 |
|
|
char buf[1000];
|
2175 |
|
|
|
2176 |
|
|
if (monitor_desc == NULL)
|
2177 |
|
|
error (_("monitor target not open."));
|
2178 |
|
|
|
2179 |
|
|
p = current_monitor->prompt;
|
2180 |
|
|
|
2181 |
|
|
/* Send the command. Note that if no args were supplied, then we're
|
2182 |
|
|
just sending the monitor a newline, which is sometimes useful. */
|
2183 |
|
|
|
2184 |
|
|
monitor_printf ("%s\r", (command ? command : ""));
|
2185 |
|
|
|
2186 |
|
|
resp_len = monitor_expect_prompt (buf, sizeof buf);
|
2187 |
|
|
|
2188 |
|
|
fputs_unfiltered (buf, outbuf); /* Output the response */
|
2189 |
|
|
}
|
2190 |
|
|
|
2191 |
|
|
/* Convert hex digit A to a number. */
|
2192 |
|
|
|
2193 |
|
|
#if 0
|
2194 |
|
|
static int
|
2195 |
|
|
from_hex (int a)
|
2196 |
|
|
{
|
2197 |
|
|
if (a >= '0' && a <= '9')
|
2198 |
|
|
return a - '0';
|
2199 |
|
|
if (a >= 'a' && a <= 'f')
|
2200 |
|
|
return a - 'a' + 10;
|
2201 |
|
|
if (a >= 'A' && a <= 'F')
|
2202 |
|
|
return a - 'A' + 10;
|
2203 |
|
|
|
2204 |
|
|
error (_("Reply contains invalid hex digit 0x%x"), a);
|
2205 |
|
|
}
|
2206 |
|
|
#endif
|
2207 |
|
|
|
2208 |
|
|
char *
|
2209 |
|
|
monitor_get_dev_name (void)
|
2210 |
|
|
{
|
2211 |
|
|
return dev_name;
|
2212 |
|
|
}
|
2213 |
|
|
|
2214 |
|
|
static struct target_ops monitor_ops;
|
2215 |
|
|
|
2216 |
|
|
static void
|
2217 |
|
|
init_base_monitor_ops (void)
|
2218 |
|
|
{
|
2219 |
|
|
monitor_ops.to_close = monitor_close;
|
2220 |
|
|
monitor_ops.to_detach = monitor_detach;
|
2221 |
|
|
monitor_ops.to_resume = monitor_resume;
|
2222 |
|
|
monitor_ops.to_wait = monitor_wait;
|
2223 |
|
|
monitor_ops.to_fetch_registers = monitor_fetch_registers;
|
2224 |
|
|
monitor_ops.to_store_registers = monitor_store_registers;
|
2225 |
|
|
monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
|
2226 |
|
|
monitor_ops.deprecated_xfer_memory = monitor_xfer_memory;
|
2227 |
|
|
monitor_ops.to_files_info = monitor_files_info;
|
2228 |
|
|
monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
|
2229 |
|
|
monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
|
2230 |
|
|
monitor_ops.to_kill = monitor_kill;
|
2231 |
|
|
monitor_ops.to_load = monitor_load;
|
2232 |
|
|
monitor_ops.to_create_inferior = monitor_create_inferior;
|
2233 |
|
|
monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
|
2234 |
|
|
monitor_ops.to_stop = monitor_stop;
|
2235 |
|
|
monitor_ops.to_rcmd = monitor_rcmd;
|
2236 |
|
|
monitor_ops.to_log_command = serial_log_command;
|
2237 |
|
|
monitor_ops.to_stratum = process_stratum;
|
2238 |
|
|
monitor_ops.to_has_all_memory = 1;
|
2239 |
|
|
monitor_ops.to_has_memory = 1;
|
2240 |
|
|
monitor_ops.to_has_stack = 1;
|
2241 |
|
|
monitor_ops.to_has_registers = 1;
|
2242 |
|
|
monitor_ops.to_has_execution = 1;
|
2243 |
|
|
monitor_ops.to_magic = OPS_MAGIC;
|
2244 |
|
|
} /* init_base_monitor_ops */
|
2245 |
|
|
|
2246 |
|
|
/* Init the target_ops structure pointed at by OPS */
|
2247 |
|
|
|
2248 |
|
|
void
|
2249 |
|
|
init_monitor_ops (struct target_ops *ops)
|
2250 |
|
|
{
|
2251 |
|
|
if (monitor_ops.to_magic != OPS_MAGIC)
|
2252 |
|
|
init_base_monitor_ops ();
|
2253 |
|
|
|
2254 |
|
|
memcpy (ops, &monitor_ops, sizeof monitor_ops);
|
2255 |
|
|
}
|
2256 |
|
|
|
2257 |
|
|
/* Define additional commands that are usually only used by monitors. */
|
2258 |
|
|
|
2259 |
|
|
extern initialize_file_ftype _initialize_remote_monitors; /* -Wmissing-prototypes */
|
2260 |
|
|
|
2261 |
|
|
void
|
2262 |
|
|
_initialize_remote_monitors (void)
|
2263 |
|
|
{
|
2264 |
|
|
init_base_monitor_ops ();
|
2265 |
|
|
add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
|
2266 |
|
|
Set display of activity while downloading a file."), _("\
|
2267 |
|
|
Show display of activity while downloading a file."), _("\
|
2268 |
|
|
When enabled, a hashmark \'#\' is displayed."),
|
2269 |
|
|
NULL,
|
2270 |
|
|
NULL, /* FIXME: i18n: */
|
2271 |
|
|
&setlist, &showlist);
|
2272 |
|
|
|
2273 |
|
|
add_setshow_zinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
|
2274 |
|
|
Set debugging of remote monitor communication."), _("\
|
2275 |
|
|
Show debugging of remote monitor communication."), _("\
|
2276 |
|
|
When enabled, communication between GDB and the remote monitor\n\
|
2277 |
|
|
is displayed."),
|
2278 |
|
|
NULL,
|
2279 |
|
|
NULL, /* FIXME: i18n: */
|
2280 |
|
|
&setdebuglist, &showdebuglist);
|
2281 |
|
|
}
|