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