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