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