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