GDB (xrefs)
/tmp/gdb-7.10/gdb/monitor.c
Go to the documentation of this file.
1 /* Remote debugging interface for boot monitors, for GDB.
2 
3  Copyright (C) 1990-2015 Free Software Foundation, Inc.
4 
5  Contributed by Cygnus Support. Written by Rob Savoye for Cygnus.
6  Resurrected from the ashes by Stu Grossman.
7 
8  This file is part of GDB.
9 
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
12  the Free Software Foundation; either version 3 of the License, or
13  (at your option) any later version.
14 
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.
19 
20  You should have received a copy of the GNU General Public License
21  along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 
23 /* This file was derived from various remote-* modules. It is a collection
24  of generic support functions so GDB can talk directly to a ROM based
25  monitor. This saves use from having to hack an exception based handler
26  into existence, and makes for quick porting.
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"
43 #include <signal.h>
44 #include <ctype.h>
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"
51 #include "infrun.h"
52 #include "gdb_regex.h"
53 #include "srec.h"
54 #include "regcache.h"
55 #include "gdbthread.h"
56 #include "readline/readline.h"
57 #include "rsp-low.h"
58 
59 static char *dev_name;
60 static struct target_ops *targ_ops;
61 
62 static void monitor_interrupt_query (void);
63 static void monitor_interrupt_twice (int);
64 static void monitor_stop (struct target_ops *self, ptid_t);
65 static void monitor_dump_regs (struct regcache *regcache);
66 
67 #if 0
68 static int from_hex (int a);
69 #endif
70 
72 
73 static int hashmark; /* flag set by "set hash". */
74 
75 static int timeout = 30;
76 
77 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait(). */
78 
79 static void (*ofunc) (); /* Old SIGINT signal handler. */
80 
82 
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 
87 static struct serial *monitor_desc = NULL;
88 
89 /* Pointer to regexp pattern matching data. */
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 
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 
103 static int dump_reg_flag; /* Non-zero means do a dump_registers cmd when
104  monitor_wait wakes up. */
105 
106 static int first_time = 0; /* Is this the first time we're
107  executing after gaving created the
108  child proccess? */
109 
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. */
116 
117 #define TARGET_BUF_SIZE 2048
118 
119 /* Monitor specific debugging information. Typically only useful to
120  the developer of a new monitor interface. */
121 
122 static void monitor_debug (const char *fmt, ...) ATTRIBUTE_PRINTF (1, 2);
123 
124 static unsigned int monitor_debug_p = 0;
125 
126 /* NOTE: This file alternates between monitor_debug_p and remote_debug
127  when determining if debug information is printed. Perhaps this
128  could be simplified. */
129 
130 static void
131 monitor_debug (const char *fmt, ...)
132 {
133  if (monitor_debug_p)
134  {
135  va_list args;
136 
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
146  string. Otherwize strlen(oldstr) is used. */
147 
148 static void
149 monitor_printable_string (char *newstr, char *oldstr, int len)
150 {
151  int ch;
152  int i;
153 
154  if (len <= 0)
155  len = strlen (oldstr);
156 
157  for (i = 0; i < len; i++)
158  {
159  ch = oldstr[i];
160  switch (ch)
161  {
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 
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  }
202  }
203 
204  *newstr++ = '\0';
205 }
206 
207 /* Print monitor errors with a string, converting the string to printable
208  representation. */
209 
210 static void
211 monitor_error (char *function, char *message,
212  CORE_ADDR memaddr, int len, char *string, int final_char)
213 {
214  int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
215  char *safe_string = alloca ((real_len * 4) + 1);
216 
217  monitor_printable_string (safe_string, string, real_len);
218 
219  if (final_char)
220  error (_("%s (%s): %s: %s%c"),
221  function, paddress (target_gdbarch (), memaddr),
222  message, safe_string, final_char);
223  else
224  error (_("%s (%s): %s: %s"),
225  function, paddress (target_gdbarch (), memaddr),
226  message, safe_string);
227 }
228 
229 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
230 
231  This function exists to get around the problem that many host platforms
232  don't have a printf that can print 64-bit addresses. The %A format
233  specification is recognized as a special case, and causes the argument
234  to be printed as a 64-bit hexadecimal address.
235 
236  Only format specifiers of the form "[0-9]*[a-z]" are recognized.
237  If it is a '%s' format, the argument is a string; otherwise the
238  argument is assumed to be a long integer.
239 
240  %% is also turned into a single %. */
241 
242 static void
243 monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
244 {
245  int addr_bit = gdbarch_addr_bit (target_gdbarch ());
246  char format[10];
247  char fmt;
248  char *p;
249  int i;
250  long arg_int;
251  CORE_ADDR arg_addr;
252  char *arg_string;
253 
254  for (p = pattern; *p; p++)
255  {
256  if (*p == '%')
257  {
258  /* Copy the format specifier to a separate buffer. */
259  format[0] = *p++;
260  for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
261  i++, p++)
262  format[i] = *p;
263  format[i] = fmt = *p;
264  format[i + 1] = '\0';
265 
266  /* Fetch the next argument and print it. */
267  switch (fmt)
268  {
269  case '%':
270  strcpy (sndbuf, "%");
271  break;
272  case 'A':
273  arg_addr = va_arg (args, CORE_ADDR);
274  strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
275  break;
276  case 's':
277  arg_string = va_arg (args, char *);
278  sprintf (sndbuf, format, arg_string);
279  break;
280  default:
281  arg_int = va_arg (args, long);
282  sprintf (sndbuf, format, arg_int);
283  break;
284  }
285  sndbuf += strlen (sndbuf);
286  }
287  else
288  *sndbuf++ = *p;
289  }
290  *sndbuf = '\0';
291 }
292 
293 
294 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
295  Works just like printf. */
296 
297 void
298 monitor_printf_noecho (char *pattern,...)
299 {
300  va_list args;
301  char sndbuf[2000];
302  int len;
303 
304  va_start (args, pattern);
305 
306  monitor_vsprintf (sndbuf, pattern, args);
307 
308  len = strlen (sndbuf);
309  if (len + 1 > sizeof sndbuf)
310  internal_error (__FILE__, __LINE__,
311  _("failed internal consistency check"));
312 
313  if (monitor_debug_p)
314  {
315  char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
316 
317  monitor_printable_string (safe_string, sndbuf, 0);
318  fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
319  }
320 
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
328 monitor_printf (char *pattern,...)
329 {
330  va_list args;
331  char sndbuf[2000];
332  int len;
333 
334  va_start (args, pattern);
335 
336  monitor_vsprintf (sndbuf, pattern, args);
337 
338  len = strlen (sndbuf);
339  if (len + 1 > sizeof sndbuf)
340  internal_error (__FILE__, __LINE__,
341  _("failed internal consistency check"));
342 
343  if (monitor_debug_p)
344  {
345  char *safe_string = (char *) alloca ((len * 4) + 1);
346 
347  monitor_printable_string (safe_string, sndbuf, 0);
348  fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
349  }
350 
351  monitor_write (sndbuf, len);
352 
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. */
358  monitor_debug ("ExpectEcho\n");
359  monitor_expect (sndbuf, (char *) 0, 0);
360 }
361 
362 
363 /* Write characters to the remote system. */
364 
365 void
366 monitor_write (char *buf, int buflen)
367 {
368  if (serial_write (monitor_desc, buf, buflen))
369  fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
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
380 {
381  int c;
382  int looping;
383 
384  do
385  {
386  looping = 0;
387  c = serial_readchar (monitor_desc, timeout);
388 
389  if (c >= 0)
390  c &= 0xff; /* don't lose bit 7 */
391  }
392  while (looping);
393 
394  if (c >= 0)
395  return c;
396 
397  if (c == SERIAL_TIMEOUT)
398  error (_("Timeout reading from remote system."));
399 
400  perror_with_name (_("remote-monitor"));
401 }
402 
403 
404 /* Read a character from the remote system, doing all the fancy
405  timeout stuff. */
406 
407 static int
408 readchar (int timeout)
409 {
410  int c;
411  static enum
412  {
413  last_random, last_nl, last_cr, last_crnl
414  }
415  state = last_random;
416  int looping;
417 
418  do
419  {
420  looping = 0;
421  c = serial_readchar (monitor_desc, timeout);
422 
423  if (c >= 0)
424  {
425  c &= 0x7f;
426  /* This seems to interfere with proper function of the
427  input stream. */
429  {
430  char buf[2];
431 
432  buf[0] = c;
433  buf[1] = '\0';
434  puts_debug ("read -->", buf, "<--");
435  }
436 
437  }
438 
439  /* Canonicialize \n\r combinations into one \r. */
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)
465 #if 0
466  /* I fail to see how detaching here can be useful. */
467  if (in_monitor_wait) /* Watchdog went off. */
468  {
470  error (_("GDB serial timeout has expired. Target detached."));
471  }
472  else
473 #endif
474  error (_("Timeout reading from remote system."));
475 
476  perror_with_name (_("remote-monitor"));
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
487 monitor_expect (char *string, char *buf, int buflen)
488 {
489  char *p = string;
490  int obuflen = buflen;
491  int c;
492 
493  if (monitor_debug_p)
494  {
495  char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
496  monitor_printable_string (safe_string, string, 0);
497  fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
498  }
499 
500  immediate_quit++;
501  QUIT;
502  while (1)
503  {
504  if (buf)
505  {
506  if (buflen < 2)
507  {
508  *buf = '\000';
509  immediate_quit--;
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 
522  /* Don't expect any ^C sent to be echoed. */
523 
524  if (*p == '\003' || c == *p)
525  {
526  p++;
527  if (*p == '\0')
528  {
529  immediate_quit--;
530 
531  if (buf)
532  {
533  *buf++ = '\000';
534  return obuflen - buflen;
535  }
536  else
537  return 0;
538  }
539  }
540  else
541  {
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
562  of what we've received so far. :) */
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
570  string[0 .. i-1] == string[p - i, p - 1]? */
571  if (! memcmp (string, p - i, i))
572  {
573  p = string + i + 1;
574  break;
575  }
576  }
577  if (i < 0)
578  p = string;
579  }
580  }
581 }
582 
583 /* Search for a regexp. */
584 
585 static int
586 monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
587 {
588  char *mybuf;
589  char *p;
590 
591  monitor_debug ("MON Expecting regexp\n");
592  if (buf)
593  mybuf = buf;
594  else
595  {
596  mybuf = alloca (TARGET_BUF_SIZE);
597  buflen = TARGET_BUF_SIZE;
598  }
599 
600  p = mybuf;
601  while (1)
602  {
603  int retval;
604 
605  if (p - mybuf >= buflen)
606  { /* Buffer about to overflow. */
607 
608 /* On overflow, we copy the upper half of the buffer to the lower half. Not
609  great, but it usually works... */
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
638 monitor_expect_prompt (char *buf, int buflen)
639 {
640  monitor_debug ("MON Expecting prompt\n");
641  return monitor_expect (current_monitor->prompt, buf, buflen);
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
649 get_hex_word (void)
650 {
651  unsigned long val;
652  int i;
653  int ch;
654 
655  do
656  ch = readchar (timeout);
657  while (isspace (ch));
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
674 compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
675  char *fastmap)
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)
689  error (_("compile_pattern: Can't compile pattern string `%s': %s!"),
690  pattern, val);
691 
692  if (fastmap)
693  re_compile_fastmap (compiled_pattern);
694 }
695 
696 /* Open a connection to a remote debugger. NAME is the filename used
697  for communication. */
698 
699 void
700 monitor_open (const char *args, struct monitor_ops *mon_ops, int from_tty)
701 {
702  const char *name;
703  char **p;
704  struct inferior *inf;
705 
706  if (mon_ops->magic != MONITOR_OPS_MAGIC)
707  error (_("Magic number of monitor_ops struct wrong."));
708 
709  targ_ops = mon_ops->target;
710  name = targ_ops->to_shortname;
711 
712  if (!args)
713  error (_("Use `target %s DEVICE-NAME' to use a serial port, or\n\
714 `target %s HOST-NAME:PORT-NUMBER' to use a network connection."), name, name);
715 
716  target_preopen (from_tty);
717 
718  /* Setup pattern for register dump. */
719 
720  if (mon_ops->register_pattern)
722  register_fastmap);
723 
724  if (mon_ops->getmem.resp_delim)
726  getmem_resp_delim_fastmap);
727 
728  if (mon_ops->setmem.resp_delim)
730  setmem_resp_delim_fastmap);
731 
732  if (mon_ops->setreg.resp_delim)
734  setreg_resp_delim_fastmap);
735 
736  unpush_target (targ_ops);
737 
738  if (dev_name)
739  xfree (dev_name);
740  dev_name = xstrdup (args);
741 
742  monitor_desc = serial_open (dev_name);
743 
744  if (!monitor_desc)
745  perror_with_name (dev_name);
746 
747  if (baud_rate != -1)
748  {
749  if (serial_setbaudrate (monitor_desc, baud_rate))
750  {
751  serial_close (monitor_desc);
752  perror_with_name (dev_name);
753  }
754  }
755 
756  serial_setparity (monitor_desc, serial_parity);
757  serial_raw (monitor_desc);
758 
759  serial_flush_input (monitor_desc);
760 
761  /* some systems only work with 2 stop bits. */
762 
763  serial_setstopbits (monitor_desc, mon_ops->stopbits);
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  {
772  monitor_stop (targ_ops, inferior_ptid);
773  if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
774  {
775  monitor_debug ("EXP Open echo\n");
776  monitor_expect_prompt (NULL, 0);
777  }
778  }
779 
780  /* wake up the monitor and see if it's alive. */
781  for (p = mon_ops->init; *p != NULL; p++)
782  {
783  /* Some of the characters we send may not be echoed,
784  but we hope to get a prompt at the end of it all. */
785 
786  if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
787  monitor_printf (*p);
788  else
790  monitor_expect_prompt (NULL, 0);
791  }
792 
793  serial_flush_input (monitor_desc);
794 
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 
801  breakaddr = (CORE_ADDR *)
802  xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
803  memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
804  }
805 
806  /* Remove all breakpoints. */
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)
815  printf_unfiltered (_("Remote target %s connected to %s\n"),
816  name, dev_name);
817 
818  push_target (targ_ops);
819 
820  /* Start afresh. */
821  init_thread_list ();
822 
823  /* Make run command think we are busy... */
825  inf = current_inferior ();
828 
829  /* Give monitor_wait something to read. */
830 
831  monitor_printf (current_monitor->line_term);
832 
834 
835  start_remote (from_tty);
836 }
837 
838 /* Close out all files and local state before this target loses
839  control. */
840 
841 void
842 monitor_close (struct target_ops *self)
843 {
844  if (monitor_desc)
845  serial_close (monitor_desc);
846 
847  /* Free breakpoint memory. */
848  if (breakaddr != NULL)
849  {
850  xfree (breakaddr);
851  breakaddr = NULL;
852  }
853 
854  monitor_desc = NULL;
855 
856  delete_thread_silent (monitor_ptid);
857  delete_inferior_silent (ptid_get_pid (monitor_ptid));
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
864 monitor_detach (struct target_ops *ops, const char *args, int from_tty)
865 {
866  unpush_target (ops); /* calls monitor_close to do the real work. */
867  if (from_tty)
868  printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
869 }
870 
871 /* Convert VALSTR into the target byte-ordered value of REGNO and store it. */
872 
873 char *
874 monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
875 {
876  struct gdbarch *gdbarch = get_regcache_arch (regcache);
877  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
878  ULONGEST val;
879  unsigned char regbuf[MAX_REGISTER_SIZE];
880  char *p;
881 
882  val = 0;
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  }
905  monitor_debug ("Supplying Register %d %s\n", regno, valstr);
906 
907  if (val == 0 && valstr == p)
908  error (_("monitor_supply_register (%d): bad value from monitor: %s."),
909  regno, valstr);
910 
911  /* supply register stores in target byte order, so swap here. */
912 
913  store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
914  val);
915 
916  regcache_raw_supply (regcache, regno, regbuf);
917 
918  return p;
919 }
920 
921 /* Tell the remote machine to resume. */
922 
923 static void
925  ptid_t ptid, int step, enum gdb_signal sig)
926 {
927  /* Some monitors require a different command when starting a program. */
928  monitor_debug ("MON resume\n");
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)
934  dump_reg_flag = 1;
935  return;
936  }
937  if (step)
938  monitor_printf (current_monitor->step);
939  else
940  {
941  if (current_monitor->continue_hook)
942  (*current_monitor->continue_hook) ();
943  else
944  monitor_printf (current_monitor->cont);
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
956 parse_register_dump (struct regcache *regcache, char *buf, int len)
957 {
958  monitor_debug ("MON Parsing register dump\n");
959  while (1)
960  {
961  int regnamelen, vallen;
962  char *regname, *val;
963 
964  /* Element 0 points to start of register name, and element 1
965  points to the start of the register value. */
966  struct re_registers register_strings;
967 
968  memset (&register_strings, 0, sizeof (struct re_registers));
969 
970  if (re_search (&register_pattern, buf, len, 0, len,
971  &register_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 
979  current_monitor->supply_register (regcache, regname, regnamelen,
980  val, vallen);
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
991 monitor_interrupt (int signo)
992 {
993  /* If this doesn't work, try more severe steps. */
994  signal (signo, monitor_interrupt_twice);
995 
997  fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
998 
1000 }
1001 
1002 /* The user typed ^C twice. */
1003 
1004 static void
1006 {
1007  signal (signo, ofunc);
1008 
1010 
1011  signal (signo, monitor_interrupt);
1012 }
1013 
1014 /* Ask the user what to do when an interrupt is received. */
1015 
1016 static void
1018 {
1020 
1021  if (query (_("Interrupted while waiting for the program.\n\
1022 Give up (and stop debugging it)? ")))
1023  {
1025  quit ();
1026  }
1027 
1029 }
1030 
1031 static void
1032 monitor_wait_cleanup (void *old_timeout)
1033 {
1034  timeout = *(int *) old_timeout;
1035  signal (SIGINT, ofunc);
1036  in_monitor_wait = 0;
1037 }
1038 
1039 
1040 
1041 static void
1043  int bufmax,
1044  int *ext_resp_len,
1045  struct target_waitstatus *status)
1046 {
1047  int resp_len;
1048 
1049  do
1050  {
1051  resp_len = monitor_expect_prompt (buf, bufmax);
1052  *ext_resp_len = resp_len;
1053 
1054  if (resp_len <= 0)
1056  "monitor_wait: excessive "
1057  "response from monitor: %s.", buf);
1058  }
1059  while (resp_len < 0);
1060 
1061  /* Print any output characters that were preceded by ^O. */
1062  /* FIXME - This would be great as a user settabgle flag. */
1064  || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
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 
1079 static ptid_t
1081  ptid_t ptid, struct target_waitstatus *status, int options)
1082 {
1083  int old_timeout = timeout;
1084  char buf[TARGET_BUF_SIZE];
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);
1092  monitor_debug ("MON wait\n");
1093 
1094 #if 0
1095  /* This is somthing other than a maintenance command. */
1096  in_monitor_wait = 1;
1097  timeout = watchdog > 0 ? watchdog : -1;
1098 #else
1099  timeout = -1; /* Don't time out -- user program is running. */
1100 #endif
1101 
1102  ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1103 
1104  if (current_monitor->wait_filter)
1105  (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1106  else
1107  monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1108 
1109 #if 0 /* Transferred to monitor wait filter. */
1110  do
1111  {
1112  resp_len = monitor_expect_prompt (buf, sizeof (buf));
1113 
1114  if (resp_len <= 0)
1116  "monitor_wait: excessive "
1117  "response from monitor: %s.", buf);
1118  }
1119  while (resp_len < 0);
1120 
1121  /* Print any output characters that were preceded by ^O. */
1122  /* FIXME - This would be great as a user settabgle flag. */
1124  || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
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  }
1132 #endif
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)
1146  parse_register_dump (get_current_regcache (), buf, resp_len);
1147 #else
1148  monitor_debug ("Wait fetching registers after stop\n");
1150 #endif
1151 
1152  status->kind = TARGET_WAITKIND_STOPPED;
1153  status->value.sig = GDB_SIGNAL_TRAP;
1154 
1155  discard_cleanups (old_chain);
1156 
1157  in_monitor_wait = 0;
1158 
1159  return inferior_ptid;
1160 }
1161 
1162 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1163  errno value. */
1164 
1165 static void
1167 {
1168  const char *name;
1169  char *zerobuf;
1170  char *regbuf;
1171  int i;
1172 
1173  regbuf = alloca (MAX_REGISTER_SIZE * 2 + 1);
1174  zerobuf = alloca (MAX_REGISTER_SIZE);
1175  memset (zerobuf, 0, MAX_REGISTER_SIZE);
1176 
1177  if (current_monitor->regname != NULL)
1178  name = current_monitor->regname (regno);
1179  else
1180  name = current_monitor->regnames[regno];
1181  monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
1182 
1183  if (!name || (*name == '\0'))
1184  {
1185  monitor_debug ("No register known for %d\n", regno);
1186  regcache_raw_supply (regcache, regno, zerobuf);
1187  return;
1188  }
1189 
1190  /* Send the register examine command. */
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  {
1200  monitor_debug ("EXP getreg.resp_delim\n");
1201  monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1202  /* Handle case of first 32 registers listed in pairs. */
1203  if (current_monitor->flags & MO_32_REGS_PAIRED
1204  && (regno & 1) != 0 && regno < 32)
1205  {
1206  monitor_debug ("EXP getreg.resp_delim\n");
1207  monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1208  }
1209  }
1210 
1211  /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1212  if (current_monitor->flags & MO_HEX_PREFIX)
1213  {
1214  int c;
1215 
1216  c = readchar (timeout);
1217  while (c == ' ')
1218  c = readchar (timeout);
1219  if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1220  ;
1221  else
1222  error (_("Bad value returned from monitor "
1223  "while fetching register %x."),
1224  regno);
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 
1231  for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)
1232  {
1233  int c;
1234 
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 
1245  regbuf[i] = '\000'; /* Terminate the number. */
1246  monitor_debug ("REGVAL '%s'\n", regbuf);
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  {
1255  monitor_debug ("EXP getreg.term\n");
1256  monitor_expect (current_monitor->getreg.term, NULL, 0); /* Get
1257  response. */
1258  }
1259 
1260  if (current_monitor->getreg.term_cmd)
1261  {
1262  monitor_debug ("EMIT getreg.term.cmd\n");
1263  monitor_printf (current_monitor->getreg.term_cmd);
1264  }
1265  if (!current_monitor->getreg.term || /* Already expected or */
1266  current_monitor->getreg.term_cmd) /* ack expected. */
1267  monitor_expect_prompt (NULL, 0); /* Get response. */
1268 
1269  monitor_supply_register (regcache, regno, regbuf);
1270 }
1271 
1272 /* Sometimes, it takes several commands to dump the registers. */
1273 /* This is a primitive for use by variations of monitor interfaces in
1274  case they need to compose the operation. */
1275 
1276 int
1277 monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)
1278 {
1279  char buf[TARGET_BUF_SIZE];
1280  int resp_len;
1281 
1282  monitor_printf (block_cmd);
1283  resp_len = monitor_expect_prompt (buf, sizeof (buf));
1284  parse_register_dump (regcache, buf, resp_len);
1285  return 1;
1286 }
1287 
1288 
1289 /* Read the remote registers into the block regs. */
1290 /* Call the specific function if it has been provided. */
1291 
1292 static void
1294 {
1295  char buf[TARGET_BUF_SIZE];
1296  int resp_len;
1297 
1298  if (current_monitor->dumpregs)
1299  (*(current_monitor->dumpregs)) (regcache); /* Call supplied function. */
1300  else if (current_monitor->dump_registers) /* Default version. */
1301  {
1302  monitor_printf (current_monitor->dump_registers);
1303  resp_len = monitor_expect_prompt (buf, sizeof (buf));
1304  parse_register_dump (regcache, buf, resp_len);
1305  }
1306  else
1307  /* Need some way to read registers. */
1308  internal_error (__FILE__, __LINE__,
1309  _("failed internal consistency check"));
1310 }
1311 
1312 static void
1314  struct regcache *regcache, int regno)
1315 {
1316  monitor_debug ("MON fetchregs\n");
1317  if (current_monitor->getreg.cmd)
1318  {
1319  if (regno >= 0)
1320  {
1321  monitor_fetch_register (regcache, regno);
1322  return;
1323  }
1324 
1325  for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
1326  regno++)
1327  monitor_fetch_register (regcache, regno);
1328  }
1329  else
1330  {
1331  monitor_dump_regs (regcache);
1332  }
1333 }
1334 
1335 /* Store register REGNO, or all if REGNO == 0. Return errno value. */
1336 
1337 static void
1339 {
1340  int reg_size = register_size (get_regcache_arch (regcache), regno);
1341  const char *name;
1342  ULONGEST val;
1343 
1344  if (current_monitor->regname != NULL)
1345  name = current_monitor->regname (regno);
1346  else
1347  name = current_monitor->regnames[regno];
1348 
1349  if (!name || (*name == '\0'))
1350  {
1351  monitor_debug ("MON Cannot store unknown register\n");
1352  return;
1353  }
1354 
1355  regcache_cooked_read_unsigned (regcache, regno, &val);
1356  monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));
1357 
1358  /* Send the register deposit command. */
1359 
1360  if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
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 
1367  if (current_monitor->setreg.resp_delim)
1368  {
1369  monitor_debug ("EXP setreg.resp_delim\n");
1371  if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1372  monitor_printf ("%s\r", phex_nz (val, reg_size));
1373  }
1374  if (current_monitor->setreg.term)
1375  {
1376  monitor_debug ("EXP setreg.term\n");
1377  monitor_expect (current_monitor->setreg.term, NULL, 0);
1378  if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1379  monitor_printf ("%s\r", phex_nz (val, reg_size));
1380  monitor_expect_prompt (NULL, 0);
1381  }
1382  else
1383  monitor_expect_prompt (NULL, 0);
1384  if (current_monitor->setreg.term_cmd) /* Mode exit required. */
1385  {
1386  monitor_debug ("EXP setreg_termcmd\n");
1387  monitor_printf ("%s", current_monitor->setreg.term_cmd);
1388  monitor_expect_prompt (NULL, 0);
1389  }
1390 } /* monitor_store_register */
1391 
1392 /* Store the remote registers. */
1393 
1394 static void
1396  struct regcache *regcache, int regno)
1397 {
1398  if (regno >= 0)
1399  {
1400  monitor_store_register (regcache, regno);
1401  return;
1402  }
1403 
1404  for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
1405  regno++)
1406  monitor_store_register (regcache, regno);
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
1417 {
1418  /* Do nothing, since we can store individual regs. */
1419 }
1420 
1421 static void
1423 {
1424  printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
1425 }
1426 
1427 static int
1428 monitor_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1429 {
1430  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1431  unsigned int val, hostval;
1432  char *cmd;
1433  int i;
1434 
1435  monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch (), memaddr));
1436 
1437  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1438  memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
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 
1448  if (i > 4) /* More than 4 zeros is worth doing. */
1449  {
1450  monitor_debug ("MON FILL %d\n", i);
1451  if (current_monitor->flags & MO_FILL_USES_ADDR)
1452  monitor_printf (current_monitor->fill, memaddr,
1453  (memaddr + i) - 1, 0);
1454  else
1455  monitor_printf (current_monitor->fill, memaddr, i, 0);
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 
1488  val = extract_unsigned_integer (myaddr, len, byte_order);
1489 
1490  if (len == 4)
1491  {
1492  hostval = *(unsigned int *) myaddr;
1493  monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
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  {
1501  monitor_printf_noecho (cmd, memaddr);
1502 
1503  if (current_monitor->setmem.resp_delim)
1504  {
1505  monitor_debug ("EXP setmem.resp_delim");
1507  monitor_printf ("%x\r", val);
1508  }
1509  if (current_monitor->setmem.term)
1510  {
1511  monitor_debug ("EXP setmem.term");
1512  monitor_expect (current_monitor->setmem.term, NULL, 0);
1513  monitor_printf ("%x\r", val);
1514  }
1515  if (current_monitor->setmem.term_cmd)
1516  { /* Emit this to get out of the memory editing state. */
1517  monitor_printf ("%s", current_monitor->setmem.term_cmd);
1518  /* Drop through to expecting a prompt. */
1519  }
1520  }
1521  else
1522  monitor_printf (cmd, memaddr, val);
1523 
1524  monitor_expect_prompt (NULL, 0);
1525 
1526  return len;
1527 }
1528 
1529 
1530 static int
1531 monitor_write_memory_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1532 {
1533  unsigned char val;
1534  int written = 0;
1535 
1536  if (len == 0)
1537  return 0;
1538  /* Enter the sub mode. */
1539  monitor_printf (current_monitor->setmem.cmdb, memaddr);
1540  monitor_expect_prompt (NULL, 0);
1541  while (len)
1542  {
1543  val = *myaddr;
1544  monitor_printf ("%x\r", val);
1545  myaddr++;
1546  memaddr++;
1547  written++;
1548  /* If we wanted to, here we could validate the address. */
1549  monitor_expect_prompt (NULL, 0);
1550  len--;
1551  }
1552  /* Now exit the sub mode. */
1553  monitor_printf (current_monitor->getreg.term_cmd);
1554  monitor_expect_prompt (NULL, 0);
1555  return written;
1556 }
1557 
1558 
1559 static void
1560 longlongendswap (unsigned char *a)
1561 {
1562  int i, j;
1563  unsigned char x;
1564 
1565  i = 0;
1566  j = 7;
1567  while (i < 4)
1568  {
1569  x = *(a + i);
1570  *(a + i) = *(a + j);
1571  *(a + j) = x;
1572  i++, j--;
1573  }
1574 }
1575 /* Format 32 chars of long long value, advance the pointer. */
1576 static char *hexlate = "0123456789abcdef";
1577 static char *
1578 longlong_hexchars (unsigned long long value,
1579  char *outbuff)
1580 {
1581  if (value == 0)
1582  {
1583  *outbuff++ = '0';
1584  return outbuff;
1585  }
1586  else
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;
1592 
1593  scan = disbuf;
1594  limit = scan + 8;
1595  {
1596  unsigned long long *dp;
1597 
1598  dp = (unsigned long long *) scan;
1599  *dp = value;
1600  }
1601  longlongendswap (disbuf); /* FIXME: ONly on big endian hosts. */
1602  while (scan < limit)
1603  {
1604  c = *scan++; /* A byte of our long long value. */
1605  if (leadzero)
1606  {
1607  if (c == 0)
1608  continue;
1609  else
1610  leadzero = 0; /* Henceforth we print even zeroes. */
1611  }
1612  nib = c >> 4; /* high nibble bits */
1613  *outbuff++ = hexlate[nib];
1614  nib = c & 0x0f; /* low nibble bits */
1615  *outbuff++ = hexlate[nib];
1616  }
1617  return outbuff;
1618  }
1619 } /* longlong_hexchars */
1620 
1621 
1622 
1623 /* I am only going to call this when writing virtual byte streams.
1624  Which possably entails endian conversions. */
1625 
1626 static int
1628 {
1629  static char hexstage[20]; /* At least 16 digits required, plus null. */
1630  char *endstring;
1631  long long *llptr;
1632  long long value;
1633  int written = 0;
1634 
1635  llptr = (long long *) myaddr;
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);
1644  *endstring = '\0'; /* NUll terminate for printf. */
1645  monitor_printf ("%s\r", hexstage);
1646  llptr++;
1647  memaddr += 8;
1648  written += 8;
1649  /* If we wanted to, here we could validate the address. */
1650  monitor_expect_prompt (NULL, 0);
1651  len -= 8;
1652  }
1653  /* Now exit the sub mode. */
1654  monitor_printf (current_monitor->getreg.term_cmd);
1655  monitor_expect_prompt (NULL, 0);
1656  return written;
1657 } /* */
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...
1668  MO_SETMEM_INTERACTIVE
1669  ! MO_NO_ECHO_ON_SETMEM
1670  To use this, the you have to patch the monitor_cmds block with
1671  this function. Otherwise, its not tuned up for use by all
1672  monitor variations. */
1673 
1674 static int
1675 monitor_write_memory_block (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
1676 {
1677  int written;
1678 
1679  written = 0;
1680  /* FIXME: This would be a good place to put the zero test. */
1681 #if 1
1682  if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1683  {
1684  return monitor_write_memory_longlongs (memaddr, myaddr, len);
1685  }
1686 #endif
1687  written = monitor_write_memory_bytes (memaddr, myaddr, len);
1688  return written;
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
1696 {
1697  enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
1698  unsigned int val;
1699  char membuf[sizeof (int) * 2 + 1];
1700  char *p;
1701  char *cmd;
1702 
1703  monitor_debug ("MON read single\n");
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)
1740  {
1741  monitor_debug ("EXP getmem.resp_delim\n");
1743  }
1744 
1745  /* Now, read the appropriate number of hex digits for this loc,
1746  skipping spaces. */
1747 
1748  /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1749  if (current_monitor->flags & MO_HEX_PREFIX)
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
1759  monitor_error ("monitor_read_memory_single",
1760  "bad response from monitor",
1761  memaddr, 0, NULL, 0);
1762  }
1763 
1764  {
1765  int i;
1766 
1767  for (i = 0; i < len * 2; i++)
1768  {
1769  int c;
1770 
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  }
1783  membuf[i] = c;
1784  }
1785  membuf[i] = '\000'; /* Terminate the number. */
1786  }
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  {
1794  monitor_expect (current_monitor->getmem.term, NULL, 0); /* Get
1795  response. */
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
1804  monitor_expect_prompt (NULL, 0); /* Get response. */
1805 
1806  p = membuf;
1807  val = strtoul (membuf, &p, 16);
1808 
1809  if (val == 0 && membuf == p)
1810  monitor_error ("monitor_read_memory_single",
1811  "bad value from monitor",
1812  memaddr, 0, membuf, 0);
1813 
1814  /* supply register stores in target byte order, so swap here. */
1815 
1816  store_unsigned_integer (myaddr, len, byte_order, val);
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
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  {
1837  monitor_debug ("Zero length call to monitor_read_memory\n");
1838  return 0;
1839  }
1840 
1841  monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
1842  paddress (target_gdbarch (), memaddr),
1843  host_address_to_string (myaddr), len);
1844 
1845  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1846  memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);
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 
1853  /* Some dumpers align the first data with the preceding 16
1854  byte boundary. Some print blanks and start at the
1855  requested boundary. EXACT_DUMPADDR */
1856 
1857  dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1858  ? memaddr : memaddr & ~0x0f;
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 
1864  /* Send the memory examine command. */
1865 
1866  if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1867  monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
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  {
1880  resp_len = monitor_expect (current_monitor->getmem.term,
1881  buf, sizeof buf); /* Get response. */
1882 
1883  if (resp_len <= 0)
1884  monitor_error ("monitor_read_memory",
1885  "excessive response from monitor",
1886  memaddr, resp_len, buf, 0);
1887 
1888  if (current_monitor->getmem.term_cmd)
1889  {
1890  serial_write (monitor_desc, current_monitor->getmem.term_cmd,
1891  strlen (current_monitor->getmem.term_cmd));
1892  monitor_expect_prompt (NULL, 0);
1893  }
1894  }
1895  else
1896  resp_len = monitor_expect_prompt (buf, sizeof buf); /* Get response. */
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;
1908 
1909  monitor_debug ("MON getmem.resp_delim %s\n",
1910  current_monitor->getmem.resp_delim);
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)
1918  monitor_error ("monitor_read_memory",
1919  "bad response from monitor",
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)
1926  monitor_error ("monitor_read_memory",
1927  "bad response from monitor",
1928  memaddr, resp_len, buf, 0);
1929  p += strlen (current_monitor->getmem.resp_delim);
1930 #endif
1931  }
1932  monitor_debug ("MON scanning %d ,%s '%s'\n", len,
1933  host_address_to_string (p), p);
1934  if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1935  {
1936  char c;
1937  int fetched = 0;
1938  i = len;
1939  c = *p;
1940 
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));
1949  *myaddr++ = val;
1951  fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
1952  --i;
1953  fetched++;
1954  }
1955  ++dumpaddr;
1956  ++p;
1957  }
1958  ++p; /* Skip a blank or other non hex char. */
1959  c = *p;
1960  }
1961  if (fetched == 0)
1962  error (_("Failed to read via monitor"));
1965  return fetched; /* Return the number of bytes actually
1966  read. */
1967  }
1968  monitor_debug ("MON scanning bytes\n");
1969 
1970  for (i = len; i > 0; i--)
1971  {
1972  /* Skip non-hex chars, but bomb on end of string and newlines. */
1973 
1974  while (1)
1975  {
1976  if (isxdigit (*p))
1977  break;
1978 
1979  if (*p == '\000' || *p == '\n' || *p == '\r')
1980  monitor_error ("monitor_read_memory",
1981  "badly terminated response from monitor",
1982  memaddr, resp_len, buf, 0);
1983  p++;
1984  }
1985 
1986  val = strtoul (p, &p1, 16);
1987 
1988  if (val == 0 && p == p1)
1989  monitor_error ("monitor_read_memory",
1990  "bad value from monitor",
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 
2004 /* Helper for monitor_xfer_partial that handles memory transfers.
2005  Arguments are like target_xfer_partial. */
2006 
2007 static enum target_xfer_status
2008 monitor_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
2009  ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
2010 {
2011  int res;
2012 
2013  if (writebuf != NULL)
2014  {
2015  if (current_monitor->flags & MO_HAS_BLOCKWRITES)
2016  res = monitor_write_memory_block (memaddr, writebuf, len);
2017  else
2018  res = monitor_write_memory (memaddr, writebuf, len);
2019  }
2020  else
2021  {
2022  res = monitor_read_memory (memaddr, readbuf, len);
2023  }
2024 
2025  if (res <= 0)
2026  return TARGET_XFER_E_IO;
2027  else
2028  {
2029  *xfered_len = (ULONGEST) res;
2030  return TARGET_XFER_OK;
2031  }
2032 }
2033 
2034 /* Target to_xfer_partial implementation. */
2035 
2036 static enum target_xfer_status
2038  const char *annex, gdb_byte *readbuf,
2039  const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
2040  ULONGEST *xfered_len)
2041 {
2042  switch (object)
2043  {
2044  case TARGET_OBJECT_MEMORY:
2045  return monitor_xfer_memory (readbuf, writebuf, offset, len, xfered_len);
2046 
2047  default:
2048  return TARGET_XFER_E_IO;
2049  }
2050 }
2051 
2052 static void
2054 {
2055  return; /* Ignore attempts to kill target system. */
2056 }
2057 
2058 /* All we actually do is set the PC to the start address of exec_bfd. */
2059 
2060 static void
2061 monitor_create_inferior (struct target_ops *ops, char *exec_file,
2062  char *args, char **env, int from_tty)
2063 {
2064  if (args && (*args != '\000'))
2065  error (_("Args are not supported by the monitor."));
2066 
2067  first_time = 1;
2070  bfd_get_start_address (exec_bfd));
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
2080 {
2081  unpush_target (targ_ops);
2082  generic_mourn_inferior (); /* Do all the proper things now. */
2083  delete_thread_silent (monitor_ptid);
2084 }
2085 
2086 /* Tell the monitor to add a breakpoint. */
2087 
2088 static int
2090  struct bp_target_info *bp_tgt)
2091 {
2092  CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
2093  int i;
2094  int bplen;
2095 
2096  monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
2097  if (current_monitor->set_break == NULL)
2098  error (_("No set_break defined for this monitor"));
2099 
2100  if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2101  addr = gdbarch_addr_bits_remove (gdbarch, addr);
2102 
2103  /* Determine appropriate breakpoint size for this address. */
2104  gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
2105  bp_tgt->placed_address = addr;
2106  bp_tgt->placed_size = bplen;
2107 
2108  for (i = 0; i < current_monitor->num_breakpoints; i++)
2109  {
2110  if (breakaddr[i] == 0)
2111  {
2112  breakaddr[i] = addr;
2113  monitor_printf (current_monitor->set_break, addr);
2114  monitor_expect_prompt (NULL, 0);
2115  return 0;
2116  }
2117  }
2118 
2119  error (_("Too many breakpoints (> %d) for monitor."),
2120  current_monitor->num_breakpoints);
2121 }
2122 
2123 /* Tell the monitor to remove a breakpoint. */
2124 
2125 static int
2127  struct bp_target_info *bp_tgt)
2128 {
2129  CORE_ADDR addr = bp_tgt->placed_address;
2130  int i;
2131 
2132  monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
2133  if (current_monitor->clr_break == NULL)
2134  error (_("No clr_break defined for this monitor"));
2135 
2136  for (i = 0; i < current_monitor->num_breakpoints; i++)
2137  {
2138  if (breakaddr[i] == addr)
2139  {
2140  breakaddr[i] = 0;
2141  /* Some monitors remove breakpoints based on the address. */
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  }
2153  "Can't find breakpoint associated with %s\n",
2154  paddress (gdbarch, addr));
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
2163 {
2164  int ch;
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 
2185 /* monitor_load -- download a file. */
2186 
2187 static void
2188 monitor_load (struct target_ops *self, const char *args, int from_tty)
2189 {
2190  CORE_ADDR load_offset = 0;
2191  char **argv;
2192  struct cleanup *old_cleanups;
2193  char *filename;
2194 
2195  monitor_debug ("MON load\n");
2196 
2197  if (args == NULL)
2198  error_no_arg (_("file to load"));
2199 
2200  argv = gdb_buildargv (args);
2201  old_cleanups = make_cleanup_freeargv (argv);
2202 
2203  filename = tilde_expand (argv[0]);
2204  make_cleanup (xfree, filename);
2205 
2206  /* Enable user to specify address for downloading as 2nd arg to load. */
2207  if (argv[1] != NULL)
2208  {
2209  const char *endptr;
2210 
2211  load_offset = strtoulst (argv[1], &endptr, 0);
2212 
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]);
2217 
2218  if (argv[2] != NULL)
2219  error (_("Too many parameters."));
2220  }
2221 
2222  monitor_printf (current_monitor->load);
2223  if (current_monitor->loadresp)
2224  monitor_expect (current_monitor->loadresp, NULL, 0);
2225 
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);
2230 
2231  monitor_expect_prompt (NULL, 0);
2232 
2233  do_cleanups (old_cleanups);
2234 
2235  /* Finally, make the PC point at the start address. */
2236  if (exec_bfd)
2238  bfd_get_start_address (exec_bfd));
2239 
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. */
2253 }
2254 
2255 static void
2257 {
2258  monitor_debug ("MON stop\n");
2259  if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2260  serial_send_break (monitor_desc);
2261  if (current_monitor->stop)
2262  monitor_printf_noecho (current_monitor->stop);
2263 }
2264 
2265 /* Put a COMMAND string out to MONITOR. Output from MONITOR is placed
2266  in OUTPUT until the prompt is seen. FIXME: We read the characters
2267  ourseleves here cause of a nasty echo. */
2268 
2269 static void
2270 monitor_rcmd (struct target_ops *self, const char *command,
2271  struct ui_file *outbuf)
2272 {
2273  char *p;
2274  int resp_len;
2275  char buf[1000];
2276 
2277  if (monitor_desc == NULL)
2278  error (_("monitor target not open."));
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 
2285  monitor_printf ("%s\r", (command ? command : ""));
2286 
2287  resp_len = monitor_expect_prompt (buf, sizeof buf);
2288 
2289  fputs_unfiltered (buf, outbuf); /* Output the response. */
2290 }
2291 
2292 /* Convert hex digit A to a number. */
2293 
2294 #if 0
2295 static int
2296 from_hex (int a)
2297 {
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 
2305  error (_("Reply contains invalid hex digit 0x%x"), a);
2306 }
2307 #endif
2308 
2309 char *
2311 {
2312  return dev_name;
2313 }
2314 
2315 /* Check to see if a thread is still alive. */
2316 
2317 static int
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 *
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 
2344 static struct target_ops monitor_ops;
2345 
2346 static void
2348 {
2349  monitor_ops.to_close = monitor_close;
2350  monitor_ops.to_detach = monitor_detach;
2351  monitor_ops.to_resume = monitor_resume;
2352  monitor_ops.to_wait = monitor_wait;
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;
2356  monitor_ops.to_xfer_partial = monitor_xfer_partial;
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;
2360  monitor_ops.to_kill = monitor_kill;
2361  monitor_ops.to_load = monitor_load;
2362  monitor_ops.to_create_inferior = monitor_create_inferior;
2363  monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2364  monitor_ops.to_stop = monitor_stop;
2365  monitor_ops.to_rcmd = monitor_rcmd;
2366  monitor_ops.to_log_command = serial_log_command;
2367  monitor_ops.to_thread_alive = monitor_thread_alive;
2368  monitor_ops.to_pid_to_str = monitor_pid_to_str;
2369  monitor_ops.to_stratum = process_stratum;
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;
2375  monitor_ops.to_magic = OPS_MAGIC;
2376 } /* init_base_monitor_ops */
2377 
2378 /* Init the target_ops structure pointed at by OPS. */
2379 
2380 void
2382 {
2383  if (monitor_ops.to_magic != OPS_MAGIC)
2385 
2386  memcpy (ops, &monitor_ops, sizeof monitor_ops);
2387 }
2388 
2389 /* Define additional commands that are usually only used by monitors. */
2390 
2391 /* -Wmissing-prototypes */
2393 
2394 void
2396 {
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);
2405 
2407 Set debugging of remote monitor communication."), _("\
2408 Show debugging of remote monitor communication."), _("\
2409 When enabled, communication between GDB and the remote monitor\n\
2410 is displayed."),
2411  NULL,
2412  NULL, /* FIXME: i18n: */
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);
2418 }
void error_no_arg(const char *why)
Definition: cli-cmds.c:205
struct gdbarch * target_gdbarch(void)
Definition: gdbarch.c:5143
struct cleanup * make_cleanup_freeargv(char **arg)
Definition: utils.c:165
const char * string
Definition: signals.c:50
char * cmdl
Definition: monitor.h:60
CORE_ADDR reqstd_address
Definition: breakpoint.h:235
int default_child_has_stack(struct target_ops *ops)
Definition: target.c:216
void target_terminal_ours(void)
Definition: target.c:491
ULONGEST extract_unsigned_integer(const gdb_byte *, int, enum bfd_endian)
Definition: findvar.c:84
char ** regnames
Definition: monitor.h:118
char * cmd
Definition: monitor.h:70
int stopbits
Definition: monitor.h:117
void monitor_printf(char *pattern,...)
Definition: monitor.c:328
int putchar_unfiltered(int c)
Definition: utils.c:2151
static void monitor_wait_filter(char *buf, int bufmax, int *ext_resp_len, struct target_waitstatus *status)
Definition: monitor.c:1042
void delete_inferior_silent(int pid)
Definition: inferior.c:232
void target_stop(ptid_t ptid)
Definition: target.c:3289
char * clr_break
Definition: monitor.h:88
#define MO_HAS_BLOCKWRITES
Definition: monitor.h:238
void monitor_close(struct target_ops *self)
Definition: monitor.c:842
void add_setshow_zuinteger_cmd(const char *name, enum command_class theclass, unsigned int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:763
char * prompt
Definition: monitor.h:113
int ptid_equal(ptid_t ptid1, ptid_t ptid2)
Definition: ptid.c:76
bfd_vma CORE_ADDR
Definition: common-types.h:41
static void monitor_debug(const char *fmt,...) ATTRIBUTE_PRINTF(1
Definition: monitor.c:131
#define MO_RUN_FIRST_TIME
Definition: monitor.h:179
#define target_shortname
Definition: target.h:1242
char * stop
Definition: monitor.h:84
#define MO_GETMEM_READ_SINGLE
Definition: monitor.h:155
void fputs_unfiltered(const char *buf, struct ui_file *file)
Definition: ui-file.c:252
struct memrw_cmd setmem
Definition: monitor.h:91
#define MO_SREC_ACK_ROTATE
Definition: monitor.h:216
void xfree(void *)
Definition: common-utils.c:97
static void monitor_resume(struct target_ops *ops, ptid_t ptid, int step, enum gdb_signal sig)
Definition: monitor.c:924
struct gdbarch * get_regcache_arch(const struct regcache *regcache)
Definition: regcache.c:297
char * loadresp
Definition: monitor.h:112
static void monitor_stop(struct target_ops *self, ptid_t)
Definition: monitor.c:2256
static void scan(struct macro_buffer *dest, struct macro_buffer *src, struct macro_name_list *no_loop, macro_lookup_ftype *lookup_func, void *lookup_baton)
Definition: macroexp.c:1367
struct type ** const(pascal_builtin_types[])
int query(const char *ctlstr,...)
Definition: utils.c:1364
void init_wait_for_inferior(void)
Definition: infrun.c:2802
char * resp_delim
Definition: monitor.h:62
static void monitor_detach(struct target_ops *ops, const char *args, int from_tty)
Definition: monitor.c:864
tuple inf
Definition: arm-linux.py:13
static char * dev_name
Definition: monitor.c:59
static int monitor_write_memory_bytes(CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
Definition: monitor.c:1531
void push_target(struct target_ops *t)
Definition: target.c:664
void delete_thread_silent(ptid_t)
Definition: thread.c:374
#define MO_SEND_BREAK_ON_STOP
Definition: monitor.h:167
#define MO_FILL_USES_ADDR
Definition: monitor.h:142
#define MO_SREC_ACK_PLUS
Definition: monitor.h:212
int unpush_target(struct target_ops *t)
Definition: target.c:711
char * args
Definition: inferior.h:320
void internal_error(const char *file, int line, const char *fmt,...)
Definition: errors.c:50
#define TARGET_BUF_SIZE
Definition: monitor.c:117
char * cmdw
Definition: monitor.h:59
static struct monitor_ops * current_monitor
Definition: monitor.c:71
void generic_mourn_inferior(void)
Definition: target.c:3171
static void monitor_mourn_inferior(struct target_ops *ops)
Definition: monitor.c:2079
int serial_setstopbits(struct serial *scb, int num)
Definition: serial.c:522
int serial_write(struct serial *scb, const void *buf, size_t count)
Definition: serial.c:403
#define MO_SETREG_INTERACTIVE
Definition: monitor.h:195
int(* wait_filter)(char *buf, int bufmax, int *response_length, struct target_waitstatus *status)
Definition: monitor.h:107
initialize_file_ftype _initialize_remote_monitors
static struct re_pattern_buffer setreg_resp_delim_pattern
Definition: monitor.c:100
int remote_debug
Definition: top.c:166
int gdbarch_num_regs(struct gdbarch *gdbarch)
Definition: gdbarch.c:1898
#define _(String)
Definition: gdb_locale.h:40
static void monitor_store_register(struct regcache *regcache, int regno)
Definition: monitor.c:1338
#define MO_EXACT_DUMPADDR
Definition: monitor.h:230
static int monitor_read_memory_single(CORE_ADDR memaddr, gdb_byte *myaddr, int len)
Definition: monitor.c:1695
static void monitor_dump_regs(struct regcache *regcache)
Definition: monitor.c:1293
static void parse_register_dump(struct regcache *regcache, char *buf, int len)
Definition: monitor.c:956
static void static unsigned int monitor_debug_p
Definition: monitor.c:124
char * cmdb
Definition: monitor.h:58
int default_child_has_execution(struct target_ops *ops, ptid_t the_ptid)
Definition: target.c:236
void regcache_write_pc(struct regcache *regcache, CORE_ADDR pc)
Definition: regcache.c:1201
static CORE_ADDR * breakaddr
Definition: monitor.c:81
static char getmem_resp_delim_fastmap[256]
Definition: monitor.c:95
struct regcache * get_current_regcache(void)
Definition: regcache.c:541
void store_unsigned_integer(gdb_byte *, int, enum bfd_endian, ULONGEST)
Definition: findvar.c:212
const char * paddress(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: utils.c:2743
Definition: ptid.h:35
void quit(void)
Definition: utils.c:1021
static void monitor_fetch_register(struct regcache *regcache, int regno)
Definition: monitor.c:1166
static void monitor_interrupt(int signo)
Definition: monitor.c:991
ptid_t ptid_build(int pid, long lwp, long tid)
Definition: ptid.c:31
static char register_fastmap[256]
Definition: monitor.c:92
int watchdog
Definition: maint.c:75
static int monitor_expect_regexp(struct re_pattern_buffer *pat, char *buf, int buflen)
Definition: monitor.c:586
static void compile_pattern(char *pattern, struct re_pattern_buffer *compiled_pattern, char *fastmap)
Definition: monitor.c:674
int default_child_has_memory(struct target_ops *ops)
Definition: target.c:206
static int timeout
Definition: monitor.c:75
void(* supply_register)(struct regcache *regcache, char *name, int namelen, char *val, int vallen)
Definition: monitor.h:103
#define MO_NEED_REGDUMP_AFTER_CONT
Definition: monitor.h:147
struct regrw_cmd getreg
Definition: monitor.h:94
char * load
Definition: monitor.h:111
static void monitor_error(char *function, char *message, CORE_ADDR memaddr, int len, char *string, int final_char)
Definition: monitor.c:211
struct cmd_list_element * setlist
Definition: cli-cmds.c:135
#define MO_ADDR_BITS_REMOVE
Definition: monitor.h:220
const char *const name
Definition: aarch64-tdep.c:68
void serial_log_command(struct target_ops *self, const char *cmd)
Definition: serial.c:132
#define OPS_MAGIC
Definition: target.h:1233
static ptid_t monitor_ptid
Definition: monitor.c:115
static int readchar(int timeout)
Definition: monitor.c:408
void monitor_write(char *buf, int buflen)
Definition: monitor.c:366
#define MO_NO_ECHO_ON_SETMEM
Definition: monitor.h:183
static void monitor_kill(struct target_ops *ops)
Definition: monitor.c:2053
static int monitor_write_memory_block(CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
Definition: monitor.c:1675
static int first_time
Definition: monitor.c:106
CORE_ADDR gdbarch_addr_bits_remove(struct gdbarch *gdbarch, CORE_ADDR addr)
Definition: gdbarch.c:2992
void initialize_file_ftype(void)
Definition: defs.h:281
char * clr_all_break
Definition: monitor.h:89
int(* dumpregs)(struct regcache *)
Definition: monitor.h:105
int monitor_expect(char *string, char *buf, int buflen)
Definition: monitor.c:487
char * cmdll
Definition: monitor.h:61
#define MO_HEX_PREFIX
Definition: monitor.h:175
static void monitor_load(struct target_ops *self, const char *args, int from_tty)
Definition: monitor.c:2188
#define exec_bfd
Definition: exec.h:32
char * term
Definition: monitor.h:63
#define MO_HANDLE_NL
Definition: monitor.h:159
struct regrw_cmd setreg
Definition: monitor.h:93
int baud_rate
Definition: serial.c:639
static void longlongendswap(unsigned char *a)
Definition: monitor.c:1560
enum register_status regcache_cooked_read_unsigned(struct regcache *regcache, int regnum, ULONGEST *val)
Definition: regcache.c:837
enum gdb_signal sig
Definition: waitstatus.h:108
void vfprintf_filtered(struct ui_file *stream, const char *format, va_list args)
Definition: utils.c:2302
void target_terminal_inferior(void)
Definition: target.c:470
void fprintf_unfiltered(struct ui_file *stream, const char *format,...)
Definition: utils.c:2361
mach_port_t mach_port_t name mach_port_t mach_port_t name error_t int status
Definition: gnu-nat.c:1816
int flags
Definition: monitor.h:80
struct cmd_list_element * showlist
Definition: cli-cmds.c:143
int serial_setbaudrate(struct serial *scb, int rate)
Definition: serial.c:516
char ** init
Definition: monitor.h:81
int serial_flush_input(struct serial *scb)
Definition: serial.c:461
#define MO_CLR_BREAK_1_BASED
Definition: monitor.h:208
int default_child_has_all_memory(struct target_ops *ops)
Definition: target.c:196
enum bfd_endian gdbarch_byte_order(struct gdbarch *gdbarch)
Definition: gdbarch.c:1420
int monitor_dump_reg_block(struct regcache *regcache, char *block_cmd)
Definition: monitor.c:1277
#define MO_CLR_BREAK_USES_ADDR
Definition: monitor.h:137
struct cleanup * make_cleanup(make_cleanup_ftype *function, void *arg)
Definition: cleanups.c:117
union target_waitstatus::@161 value
target_xfer_status
Definition: target.h:219
static void(* ofunc)()
Definition: monitor.c:79
static enum target_xfer_status monitor_xfer_memory(gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
Definition: monitor.c:2008
#define MO_PRINT_PROGRAM_OUTPUT
Definition: monitor.h:224
#define MONITOR_OPS_MAGIC
Definition: monitor.h:130
int serial_send_break(struct serial *scb)
Definition: serial.c:467
void target_mourn_inferior(void)
Definition: target.c:2300
char * step
Definition: monitor.h:83
static enum target_xfer_status monitor_xfer_partial(struct target_ops *ops, enum target_object object, const char *annex, gdb_byte *readbuf, const gdb_byte *writebuf, ULONGEST offset, ULONGEST len, ULONGEST *xfered_len)
Definition: monitor.c:2037
static void monitor_store_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: monitor.c:1395
void serial_raw(struct serial *scb)
Definition: serial.c:476
#define min(a, b)
Definition: defs.h:106
static void monitor_prepare_to_store(struct target_ops *self, struct regcache *regcache)
Definition: monitor.c:1416
void puts_debug(char *prefix, char *string, char *suffix)
Definition: utils.c:2192
Definition: serial.h:227
static int monitor_remove_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: monitor.c:2126
struct thread_info * add_thread_silent(ptid_t ptid)
Definition: thread.c:240
int gdbarch_addr_bit(struct gdbarch *gdbarch)
Definition: gdbarch.c:1707
ULONGEST strtoulst(const char *num, const char **trailer, int base)
Definition: common-utils.c:188
static int monitor_write_memory(CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
Definition: monitor.c:1428
void printf_unfiltered(const char *format,...)
Definition: utils.c:2399
struct cmd_list_element * setdebuglist
Definition: cli-cmds.c:173
CORE_ADDR placed_address
Definition: breakpoint.h:232
static int hashmark
Definition: monitor.c:73
int fromhex(int a)
Definition: rsp-low.c:26
void monitor_open(const char *args, struct monitor_ops *mon_ops, int from_tty)
Definition: monitor.c:700
void * xmalloc(YYSIZE_T)
struct ui_file * gdb_stdlog
Definition: main.c:73
char * term
Definition: monitor.h:73
struct memrw_cmd getmem
Definition: monitor.h:92
target_object
Definition: target.h:136
static int monitor_wait_srec_ack(void)
Definition: monitor.c:2162
static char * longlong_hexchars(unsigned long long value, char *outbuff)
Definition: monitor.c:1578
void serial_close(struct serial *scb)
Definition: serial.c:340
char * normal_pid_to_str(ptid_t ptid)
Definition: target.c:3207
static struct re_pattern_buffer getmem_resp_delim_pattern
Definition: monitor.c:94
char * register_pattern
Definition: monitor.h:101
static void monitor_vsprintf(char *sndbuf, char *pattern, va_list args)
Definition: monitor.c:243
struct serial * serial_open(const char *name)
Definition: serial.c:185
Definition: value.c:172
int ptid_get_pid(ptid_t ptid)
Definition: ptid.c:52
static void init_base_monitor_ops(void)
Definition: monitor.c:2347
static void monitor_wait_cleanup(void *old_timeout)
Definition: monitor.c:1032
const char const char int
Definition: command.h:229
bfd_byte gdb_byte
Definition: common-types.h:38
int immediate_quit
void start_remote(int from_tty)
Definition: infrun.c:2768
void discard_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:213
#define MO_GETMEM_16_BOUNDARY
Definition: monitor.h:204
void init_monitor_ops(struct target_ops *ops)
Definition: monitor.c:2381
void void void void void void void void void perror_with_name(const char *string) ATTRIBUTE_NORETURN
Definition: utils.c:979
int default_child_has_registers(struct target_ops *ops)
Definition: target.c:226
static int dump_reg_flag
Definition: monitor.c:103
int xsnprintf(char *str, size_t size, const char *format,...)
Definition: common-utils.c:134
void clear_proceed_status(int step)
Definition: infrun.c:2463
char * dump_registers
Definition: monitor.h:100
enum target_waitkind kind
Definition: waitstatus.h:100
char * term_cmd
Definition: monitor.h:74
const gdb_byte * gdbarch_breakpoint_from_pc(struct gdbarch *gdbarch, CORE_ADDR *pcptr, int *lenptr)
Definition: gdbarch.c:2662
struct ui_file * gdb_stderr
Definition: main.c:72
static int in_monitor_wait
Definition: monitor.c:77
#define MO_SETMEM_INTERACTIVE
Definition: monitor.h:199
ptid_t inferior_ptid
Definition: infcmd.c:124
#define MO_32_REGS_PAIRED
Definition: monitor.h:191
char * safe_strerror(int)
int magic
Definition: monitor.h:124
int offset
Definition: agent.c:65
static int monitor_thread_alive(struct target_ops *ops, ptid_t ptid)
Definition: monitor.c:2318
int serial_parity
Definition: serial.c:651
char ** gdb_buildargv(const char *s)
Definition: utils.c:3036
static int monitor_insert_breakpoint(struct target_ops *ops, struct gdbarch *gdbarch, struct bp_target_info *bp_tgt)
Definition: monitor.c:2089
#define SREC_ALL
Definition: srec.h:33
int(* continue_hook)(void)
Definition: monitor.h:106
char * monitor_supply_register(struct regcache *regcache, int regno, char *valstr)
Definition: monitor.c:874
int monitor_readchar(void)
Definition: monitor.c:379
static char * monitor_pid_to_str(struct target_ops *ops, ptid_t ptid)
Definition: monitor.c:2331
struct target_ops * target
Definition: monitor.h:116
struct inferior * current_inferior(void)
Definition: inferior.c:57
void regcache_raw_supply(struct regcache *regcache, int regnum, const void *buf)
Definition: regcache.c:1041
const char * to_shortname
Definition: target.h:432
static char setreg_resp_delim_fastmap[256]
Definition: monitor.c:101
char * monitor_get_dev_name(void)
Definition: monitor.c:2310
unsigned long long ULONGEST
Definition: common-types.h:53
static int monitor_read_memory(CORE_ADDR memaddr, gdb_byte *myaddr, int len)
Definition: monitor.c:1826
static void ATTRIBUTE_PRINTF(6, 0)
Definition: cli-out.c:229
int serial_setparity(struct serial *scb, int parity)
Definition: serial.c:530
static void monitor_interrupt_query(void)
Definition: monitor.c:1017
int register_size(struct gdbarch *gdbarch, int regnum)
Definition: regcache.c:169
char * fill
Definition: monitor.h:90
static void monitor_create_inferior(struct target_ops *ops, char *exec_file, char *args, char **env, int from_tty)
Definition: monitor.c:2061
#define MO_SREC_ACK
Definition: monitor.h:171
static int monitor_write_memory_longlongs(CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
Definition: monitor.c:1627
void load_srec(struct serial *desc, const char *file, bfd_vma load_offset, int maxrecsize, int flags, int hashmark, int(*waitack)(void))
Definition: dsrec.c:45
struct cmd_list_element * showdebuglist
Definition: cli-cmds.c:175
static ptid_t monitor_wait(struct target_ops *ops, ptid_t ptid, struct target_waitstatus *status, int options)
Definition: monitor.c:1080
int num_breakpoints
Definition: monitor.h:122
#define MO_REGISTER_VALUE_FIRST
Definition: monitor.h:187
static struct re_pattern_buffer setmem_resp_delim_pattern
Definition: monitor.c:97
void target_preopen(int from_tty)
Definition: target.c:2171
char * resp_delim
Definition: monitor.h:71
int serial_readchar(struct serial *scb, int timeout)
Definition: serial.c:372
static char setmem_resp_delim_fastmap[256]
Definition: monitor.c:98
int monitor_expect_prompt(char *buf, int buflen)
Definition: monitor.c:638
#define QUIT
Definition: defs.h:160
#define MO_NO_ECHO_ON_OPEN
Definition: monitor.h:163
static struct target_ops * targ_ops
Definition: monitor.c:60
char * set_break
Definition: monitor.h:85
#define MO_GETMEM_NEEDS_RANGE
Definition: monitor.h:151
enum bfd_endian byte_order
Definition: gdbarch.c:128
void monitor_printf_noecho(char *pattern,...)
Definition: monitor.c:298
const char *(* regname)(int index)
Definition: monitor.h:120
static void monitor_interrupt_twice(int)
Definition: monitor.c:1005
char * line_term
Definition: monitor.h:114
static void monitor_fetch_registers(struct target_ops *ops, struct regcache *regcache, int regno)
Definition: monitor.c:1313
static void monitor_rcmd(struct target_ops *self, const char *command, struct ui_file *outbuf)
Definition: monitor.c:2270
char * cont
Definition: monitor.h:82
void error(const char *fmt,...)
Definition: errors.c:38
static void monitor_printable_string(char *newstr, char *oldstr, int len)
Definition: monitor.c:149
void inferior_appeared(struct inferior *inf, int pid)
Definition: inferior.c:320
void do_cleanups(struct cleanup *old_chain)
Definition: cleanups.c:175
static struct re_pattern_buffer register_pattern
Definition: monitor.c:91
void add_setshow_boolean_cmd(const char *name, enum command_class theclass, int *var, const char *set_doc, const char *show_doc, const char *help_doc, cmd_sfunc_ftype *set_func, show_value_ftype *show_func, struct cmd_list_element **set_list, struct cmd_list_element **show_list)
Definition: cli-decode.c:541
static void monitor_files_info(struct target_ops *ops)
Definition: monitor.c:1422
void init_thread_list(void)
Definition: thread.c:198
char * term_cmd
Definition: monitor.h:64
const ULONGEST const LONGEST len
Definition: target.h:309