Remove ATTRIBUTE_UNUSED. Update (C).
[external/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   extern struct target_ops *targ_ops;
525
526   if (monitor_debug_p)
527     {
528       char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
529       monitor_printable_string (safe_string, string, 0);
530       fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
531     }
532
533   immediate_quit++;
534   while (1)
535     {
536       if (buf)
537         {
538           if (buflen < 2)
539             {
540               *buf = '\000';
541               immediate_quit--;
542               return -1;
543             }
544
545           c = readchar (timeout);
546           if (c == '\000')
547             continue;
548           *buf++ = c;
549           buflen--;
550         }
551       else
552         c = readchar (timeout);
553
554       /* Don't expect any ^C sent to be echoed */
555
556       if (*p == '\003' || c == *p)
557         {
558           p++;
559           if (*p == '\0')
560             {
561               immediate_quit--;
562
563               if (buf)
564                 {
565                   *buf++ = '\000';
566                   return obuflen - buflen;
567                 }
568               else
569                 return 0;
570             }
571         }
572       else if ((c == '\021' || c == '\023') &&
573                (STREQ (targ_ops->to_shortname, "m32r")
574                 || STREQ (targ_ops->to_shortname, "mon2000")))
575         {                       /* m32r monitor emits random DC1/DC3 chars */
576           continue;
577         }
578       else
579         {
580           /* We got a character that doesn't match the string.  We need to
581              back up p, but how far?  If we're looking for "..howdy" and the
582              monitor sends "...howdy"?  There's certainly a match in there,
583              but when we receive the third ".", we won't find it if we just
584              restart the matching at the beginning of the string.
585
586              This is a Boyer-Moore kind of situation.  We want to reset P to
587              the end of the longest prefix of STRING that is a suffix of
588              what we've read so far.  In the example above, that would be
589              ".." --- the longest prefix of "..howdy" that is a suffix of
590              "...".  This longest prefix could be the empty string, if C
591              is nowhere to be found in STRING.
592
593              If this longest prefix is not the empty string, it must contain
594              C, so let's search from the end of STRING for instances of C,
595              and see if the portion of STRING before that is a suffix of
596              what we read before C.  Actually, we can search backwards from
597              p, since we know no prefix can be longer than that.
598
599              Note that we can use STRING itself, along with C, as a record
600              of what we've received so far.  :) */
601           int i;
602
603           for (i = (p - string) - 1; i >= 0; i--)
604             if (string[i] == c)
605               {
606                 /* Is this prefix a suffix of what we've read so far?
607                    In other words, does
608                      string[0 .. i-1] == string[p - i, p - 1]? */
609                 if (! memcmp (string, p - i, i))
610                   {
611                     p = string + i + 1;
612                     break;
613                   }
614               }
615           if (i < 0)
616             p = string;
617         }
618     }
619 }
620
621 /* Search for a regexp.  */
622
623 static int
624 monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
625 {
626   char *mybuf;
627   char *p;
628   monitor_debug ("MON Expecting regexp\n");
629   if (buf)
630     mybuf = buf;
631   else
632     {
633       mybuf = alloca (TARGET_BUF_SIZE);
634       buflen = TARGET_BUF_SIZE;
635     }
636
637   p = mybuf;
638   while (1)
639     {
640       int retval;
641
642       if (p - mybuf >= buflen)
643         {                       /* Buffer about to overflow */
644
645 /* On overflow, we copy the upper half of the buffer to the lower half.  Not
646    great, but it usually works... */
647
648           memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
649           p = mybuf + buflen / 2;
650         }
651
652       *p++ = readchar (timeout);
653
654       retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
655       if (retval >= 0)
656         return 1;
657     }
658 }
659
660 /* Keep discarding input until we see the MONITOR prompt.
661
662    The convention for dealing with the prompt is that you
663    o give your command
664    o *then* wait for the prompt.
665
666    Thus the last thing that a procedure does with the serial line will
667    be an monitor_expect_prompt().  Exception: monitor_resume does not
668    wait for the prompt, because the terminal is being handed over to
669    the inferior.  However, the next thing which happens after that is
670    a monitor_wait which does wait for the prompt.  Note that this
671    includes abnormal exit, e.g. error().  This is necessary to prevent
672    getting into states from which we can't recover.  */
673
674 int
675 monitor_expect_prompt (char *buf, int buflen)
676 {
677   monitor_debug ("MON Expecting prompt\n");
678   return monitor_expect (current_monitor->prompt, buf, buflen);
679 }
680
681 /* Get N 32-bit words from remote, each preceded by a space, and put
682    them in registers starting at REGNO.  */
683
684 #if 0
685 static unsigned long
686 get_hex_word (void)
687 {
688   unsigned long val;
689   int i;
690   int ch;
691
692   do
693     ch = readchar (timeout);
694   while (isspace (ch));
695
696   val = from_hex (ch);
697
698   for (i = 7; i >= 1; i--)
699     {
700       ch = readchar (timeout);
701       if (!isxdigit (ch))
702         break;
703       val = (val << 4) | from_hex (ch);
704     }
705
706   return val;
707 }
708 #endif
709
710 static void
711 compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
712                  char *fastmap)
713 {
714   int tmp;
715   const char *val;
716
717   compiled_pattern->fastmap = fastmap;
718
719   tmp = re_set_syntax (RE_SYNTAX_EMACS);
720   val = re_compile_pattern (pattern,
721                             strlen (pattern),
722                             compiled_pattern);
723   re_set_syntax (tmp);
724
725   if (val)
726     error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
727
728   if (fastmap)
729     re_compile_fastmap (compiled_pattern);
730 }
731
732 /* Open a connection to a remote debugger. NAME is the filename used
733    for communication.  */
734
735 void
736 monitor_open (char *args, struct monitor_ops *mon_ops, int from_tty)
737 {
738   char *name;
739   char **p;
740
741   if (mon_ops->magic != MONITOR_OPS_MAGIC)
742     error ("Magic number of monitor_ops struct wrong.");
743
744   targ_ops = mon_ops->target;
745   name = targ_ops->to_shortname;
746
747   if (!args)
748     error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
749 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
750
751   target_preopen (from_tty);
752
753   /* Setup pattern for register dump */
754
755   if (mon_ops->register_pattern)
756     compile_pattern (mon_ops->register_pattern, &register_pattern,
757                      register_fastmap);
758
759   if (mon_ops->getmem.resp_delim)
760     compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
761                      getmem_resp_delim_fastmap);
762
763   if (mon_ops->setmem.resp_delim)
764     compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
765                      setmem_resp_delim_fastmap);
766
767   if (mon_ops->setreg.resp_delim)
768     compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
769                      setreg_resp_delim_fastmap);
770   
771   unpush_target (targ_ops);
772
773   if (dev_name)
774     xfree (dev_name);
775   dev_name = xstrdup (args);
776
777   monitor_desc = serial_open (dev_name);
778
779   if (!monitor_desc)
780     perror_with_name (dev_name);
781
782   if (baud_rate != -1)
783     {
784       if (serial_setbaudrate (monitor_desc, baud_rate))
785         {
786           serial_close (monitor_desc);
787           perror_with_name (dev_name);
788         }
789     }
790
791   serial_raw (monitor_desc);
792
793   serial_flush_input (monitor_desc);
794
795   /* some systems only work with 2 stop bits */
796
797   serial_setstopbits (monitor_desc, mon_ops->stopbits);
798
799   current_monitor = mon_ops;
800
801   /* See if we can wake up the monitor.  First, try sending a stop sequence,
802      then send the init strings.  Last, remove all breakpoints.  */
803
804   if (current_monitor->stop)
805     {
806       monitor_stop ();
807       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
808         {
809           monitor_debug ("EXP Open echo\n");
810           monitor_expect_prompt (NULL, 0);
811         }
812     }
813
814   /* wake up the monitor and see if it's alive */
815   for (p = mon_ops->init; *p != NULL; p++)
816     {
817       /* Some of the characters we send may not be echoed,
818          but we hope to get a prompt at the end of it all. */
819
820       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
821         monitor_printf (*p);
822       else
823         monitor_printf_noecho (*p);
824       monitor_expect_prompt (NULL, 0);
825     }
826
827   serial_flush_input (monitor_desc);
828
829   /* Alloc breakpoints */
830   if (mon_ops->set_break != NULL)
831     {
832       if (mon_ops->num_breakpoints == 0)
833         mon_ops->num_breakpoints = 8;
834
835       breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
836       memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
837     }
838
839   /* Remove all breakpoints */
840
841   if (mon_ops->clr_all_break)
842     {
843       monitor_printf (mon_ops->clr_all_break);
844       monitor_expect_prompt (NULL, 0);
845     }
846
847   if (from_tty)
848     printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
849
850   push_target (targ_ops);
851
852   inferior_ptid = pid_to_ptid (42000);  /* Make run command think we are busy... */
853
854   /* Give monitor_wait something to read */
855
856   monitor_printf (current_monitor->line_term);
857
858   start_remote ();
859 }
860
861 /* Close out all files and local state before this target loses
862    control.  */
863
864 void
865 monitor_close (int quitting)
866 {
867   if (monitor_desc)
868     serial_close (monitor_desc);
869
870   /* Free breakpoint memory */
871   if (breakaddr != NULL)
872     {
873       xfree (breakaddr);
874       breakaddr = NULL;
875     }
876
877   monitor_desc = NULL;
878 }
879
880 /* Terminate the open connection to the remote debugger.  Use this
881    when you want to detach and do something else with your gdb.  */
882
883 static void
884 monitor_detach (char *args, int from_tty)
885 {
886   pop_target ();                /* calls monitor_close to do the real work */
887   if (from_tty)
888     printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
889 }
890
891 /* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */
892
893 char *
894 monitor_supply_register (int regno, char *valstr)
895 {
896   ULONGEST val;
897   unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
898   char *p;
899
900   val = 0;
901   p = valstr;
902   while (p && *p != '\0')
903     {
904       if (*p == '\r' || *p == '\n')
905         {
906           while (*p != '\0') 
907               p++;
908           break;
909         }
910       if (isspace (*p))
911         {
912           p++;
913           continue;
914         }
915       if (!isxdigit (*p) && *p != 'x')
916         {
917           break;
918         }
919
920       val <<= 4;
921       val += fromhex (*p++);
922     }
923   monitor_debug ("Supplying Register %d %s\n", regno, valstr);
924
925   if (val == 0 && valstr == p)
926     error ("monitor_supply_register (%d):  bad value from monitor: %s.",
927            regno, valstr);
928
929   /* supply register stores in target byte order, so swap here */
930
931   store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
932
933   supply_register (regno, regbuf);
934
935   return p;
936 }
937
938 /* Tell the remote machine to resume.  */
939
940 static void
941 monitor_resume (ptid_t ptid, int step, enum target_signal sig)
942 {
943   /* Some monitors require a different command when starting a program */
944   monitor_debug ("MON resume\n");
945   if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
946     {
947       first_time = 0;
948       monitor_printf ("run\r");
949       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
950         dump_reg_flag = 1;
951       return;
952     }
953   if (step)
954     monitor_printf (current_monitor->step);
955   else
956     {
957       if (current_monitor->continue_hook)
958         (*current_monitor->continue_hook) ();
959       else
960         monitor_printf (current_monitor->cont);
961       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
962         dump_reg_flag = 1;
963     }
964 }
965
966 /* Parse the output of a register dump command.  A monitor specific
967    regexp is used to extract individual register descriptions of the
968    form REG=VAL.  Each description is split up into a name and a value
969    string which are passed down to monitor specific code.  */
970
971 static void
972 parse_register_dump (char *buf, int len)
973 {
974   monitor_debug ("MON Parsing  register dump\n");
975   while (1)
976     {
977       int regnamelen, vallen;
978       char *regname, *val;
979       /* Element 0 points to start of register name, and element 1
980          points to the start of the register value.  */
981       struct re_registers register_strings;
982
983       memset (&register_strings, 0, sizeof (struct re_registers));
984
985       if (re_search (&register_pattern, buf, len, 0, len,
986                      &register_strings) == -1)
987         break;
988
989       regnamelen = register_strings.end[1] - register_strings.start[1];
990       regname = buf + register_strings.start[1];
991       vallen = register_strings.end[2] - register_strings.start[2];
992       val = buf + register_strings.start[2];
993
994       current_monitor->supply_register (regname, regnamelen, val, vallen);
995
996       buf += register_strings.end[0];
997       len -= register_strings.end[0];
998     }
999 }
1000
1001 /* Send ^C to target to halt it.  Target will respond, and send us a
1002    packet.  */
1003
1004 static void
1005 monitor_interrupt (int signo)
1006 {
1007   /* If this doesn't work, try more severe steps.  */
1008   signal (signo, monitor_interrupt_twice);
1009
1010   if (monitor_debug_p || remote_debug)
1011     fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");
1012
1013   target_stop ();
1014 }
1015
1016 /* The user typed ^C twice.  */
1017
1018 static void
1019 monitor_interrupt_twice (int signo)
1020 {
1021   signal (signo, ofunc);
1022
1023   monitor_interrupt_query ();
1024
1025   signal (signo, monitor_interrupt);
1026 }
1027
1028 /* Ask the user what to do when an interrupt is received.  */
1029
1030 static void
1031 monitor_interrupt_query (void)
1032 {
1033   target_terminal_ours ();
1034
1035   if (query ("Interrupted while waiting for the program.\n\
1036 Give up (and stop debugging it)? "))
1037     {
1038       target_mourn_inferior ();
1039       return_to_top_level (RETURN_QUIT);
1040     }
1041
1042   target_terminal_inferior ();
1043 }
1044
1045 static void
1046 monitor_wait_cleanup (void *old_timeout)
1047 {
1048   timeout = *(int *) old_timeout;
1049   signal (SIGINT, ofunc);
1050   in_monitor_wait = 0;
1051 }
1052
1053
1054
1055 void
1056 monitor_wait_filter (char *buf,
1057                      int bufmax,
1058                      int *ext_resp_len,
1059                      struct target_waitstatus *status
1060 )
1061 {
1062   int resp_len;
1063   do
1064     {
1065       resp_len = monitor_expect_prompt (buf, bufmax);
1066       *ext_resp_len = resp_len;
1067
1068       if (resp_len <= 0)
1069         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive 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 (ptid_t ptid, struct target_waitstatus *status)
1093 {
1094   int old_timeout = timeout;
1095   char buf[TARGET_BUF_SIZE];
1096   int resp_len;
1097   struct cleanup *old_chain;
1098
1099   status->kind = TARGET_WAITKIND_EXITED;
1100   status->value.integer = 0;
1101
1102   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
1103   monitor_debug ("MON wait\n");
1104
1105 #if 0
1106   /* This is somthing other than a maintenance command */
1107     in_monitor_wait = 1;
1108   timeout = watchdog > 0 ? watchdog : -1;
1109 #else
1110   timeout = -1;         /* Don't time out -- user program is running. */
1111 #endif
1112
1113   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1114
1115   if (current_monitor->wait_filter)
1116     (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1117   else
1118     monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1119
1120 #if 0                           /* Transferred to monitor wait filter */
1121   do
1122     {
1123       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1124
1125       if (resp_len <= 0)
1126         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
1127     }
1128   while (resp_len < 0);
1129
1130   /* Print any output characters that were preceded by ^O.  */
1131   /* FIXME - This would be great as a user settabgle flag */
1132   if (monitor_debug_p || remote_debug
1133       || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1134     {
1135       int i;
1136
1137       for (i = 0; i < resp_len - 1; i++)
1138         if (buf[i] == 0x0f)
1139           putchar_unfiltered (buf[++i]);
1140     }
1141 #endif
1142
1143   signal (SIGINT, ofunc);
1144
1145   timeout = old_timeout;
1146 #if 0
1147   if (dump_reg_flag && current_monitor->dump_registers)
1148     {
1149       dump_reg_flag = 0;
1150       monitor_printf (current_monitor->dump_registers);
1151       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1152     }
1153
1154   if (current_monitor->register_pattern)
1155     parse_register_dump (buf, resp_len);
1156 #else
1157   monitor_debug ("Wait fetching registers after stop\n");
1158   monitor_dump_regs ();
1159 #endif
1160
1161   status->kind = TARGET_WAITKIND_STOPPED;
1162   status->value.sig = TARGET_SIGNAL_TRAP;
1163
1164   discard_cleanups (old_chain);
1165
1166   in_monitor_wait = 0;
1167
1168   return inferior_ptid;
1169 }
1170
1171 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1172    errno value.  */
1173
1174 static void
1175 monitor_fetch_register (int regno)
1176 {
1177   char *name;
1178   char *zerobuf;
1179   char *regbuf;
1180   int i;
1181
1182   regbuf  = alloca (MAX_REGISTER_RAW_SIZE * 2 + 1);
1183   zerobuf = alloca (MAX_REGISTER_RAW_SIZE);
1184   memset (zerobuf, 0, MAX_REGISTER_RAW_SIZE);
1185
1186   name = current_monitor->regnames[regno];
1187   monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");
1188
1189   if (!name || (*name == '\0'))
1190     {
1191       monitor_debug ("No register known for %d\n", regno);
1192       supply_register (regno, zerobuf);
1193       return;
1194     }
1195
1196   /* send the register examine command */
1197
1198   monitor_printf (current_monitor->getreg.cmd, name);
1199
1200   /* If RESP_DELIM is specified, we search for that as a leading
1201      delimiter for the register value.  Otherwise, we just start
1202      searching from the start of the buf.  */
1203
1204   if (current_monitor->getreg.resp_delim)
1205     {
1206       monitor_debug ("EXP getreg.resp_delim\n");
1207       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1208       /* Handle case of first 32 registers listed in pairs.  */
1209       if (current_monitor->flags & MO_32_REGS_PAIRED
1210           && (regno & 1) != 0 && regno < 32)
1211         {
1212           monitor_debug ("EXP getreg.resp_delim\n");
1213           monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1214         }
1215     }
1216
1217   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1218   if (current_monitor->flags & MO_HEX_PREFIX)
1219     {
1220       int c;
1221       c = readchar (timeout);
1222       while (c == ' ')
1223         c = readchar (timeout);
1224       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1225         ;
1226       else
1227         error ("Bad value returned from monitor while fetching register %x.",
1228                regno);
1229     }
1230
1231   /* Read upto the maximum number of hex digits for this register, skipping
1232      spaces, but stop reading if something else is seen.  Some monitors
1233      like to drop leading zeros.  */
1234
1235   for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
1236     {
1237       int c;
1238       c = readchar (timeout);
1239       while (c == ' ')
1240         c = readchar (timeout);
1241
1242       if (!isxdigit (c))
1243         break;
1244
1245       regbuf[i] = c;
1246     }
1247
1248   regbuf[i] = '\000';           /* terminate the number */
1249   monitor_debug ("REGVAL '%s'\n", regbuf);
1250
1251   /* If TERM is present, we wait for that to show up.  Also, (if TERM
1252      is present), we will send TERM_CMD if that is present.  In any
1253      case, we collect all of the output into buf, and then wait for
1254      the normal prompt.  */
1255
1256   if (current_monitor->getreg.term)
1257     {
1258       monitor_debug ("EXP getreg.term\n");
1259       monitor_expect (current_monitor->getreg.term, NULL, 0);           /* get response */
1260     }
1261
1262   if (current_monitor->getreg.term_cmd)
1263     {
1264       monitor_debug ("EMIT getreg.term.cmd\n");
1265       monitor_printf (current_monitor->getreg.term_cmd);
1266     }
1267   if (!current_monitor->getreg.term ||  /* Already expected or */
1268       current_monitor->getreg.term_cmd)         /* ack expected */
1269     monitor_expect_prompt (NULL, 0);    /* get response */
1270
1271   monitor_supply_register (regno, regbuf);
1272 }
1273
1274 /* Sometimes, it takes several commands to dump the registers */
1275 /* This is a primitive for use by variations of monitor interfaces in
1276    case they need to compose the operation.
1277  */
1278 int
1279 monitor_dump_reg_block (char *block_cmd)
1280 {
1281   char buf[TARGET_BUF_SIZE];
1282   int resp_len;
1283   monitor_printf (block_cmd);
1284   resp_len = monitor_expect_prompt (buf, sizeof (buf));
1285   parse_register_dump (buf, resp_len);
1286   return 1;
1287 }
1288
1289
1290 /* Read the remote registers into the block regs.  */
1291 /* Call the specific function if it has been provided */
1292
1293 static void
1294 monitor_dump_regs (void)
1295 {
1296   char buf[TARGET_BUF_SIZE];
1297   int resp_len;
1298   if (current_monitor->dumpregs)
1299     (*(current_monitor->dumpregs)) ();  /* call supplied function */
1300   else if (current_monitor->dump_registers)     /* default version */
1301     {
1302       monitor_printf (current_monitor->dump_registers);
1303       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1304       parse_register_dump (buf, resp_len);
1305     }
1306   else
1307     internal_error (__FILE__, __LINE__, "failed internal consistency check");                   /* Need some way to read registers */
1308 }
1309
1310 static void
1311 monitor_fetch_registers (int regno)
1312 {
1313   monitor_debug ("MON fetchregs\n");
1314   if (current_monitor->getreg.cmd)
1315     {
1316       if (regno >= 0)
1317         {
1318           monitor_fetch_register (regno);
1319           return;
1320         }
1321
1322       for (regno = 0; regno < NUM_REGS; regno++)
1323         monitor_fetch_register (regno);
1324     }
1325   else
1326     {
1327       monitor_dump_regs ();
1328     }
1329 }
1330
1331 /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
1332
1333 static void
1334 monitor_store_register (int regno)
1335 {
1336   char *name;
1337   ULONGEST val;
1338
1339   name = current_monitor->regnames[regno];
1340   if (!name || (*name == '\0'))
1341     {
1342       monitor_debug ("MON Cannot store unknown register\n");
1343       return;
1344     }
1345
1346   val = read_register (regno);
1347   monitor_debug ("MON storeg %d %s\n", regno,
1348                  phex (val, REGISTER_RAW_SIZE (regno)));
1349
1350   /* send the register deposit command */
1351
1352   if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1353     monitor_printf (current_monitor->setreg.cmd, val, name);
1354   else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1355     monitor_printf (current_monitor->setreg.cmd, name);
1356   else
1357     monitor_printf (current_monitor->setreg.cmd, name, val);
1358
1359   if (current_monitor->setreg.resp_delim)
1360     {
1361       monitor_debug ("EXP setreg.resp_delim\n");
1362       monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
1363       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1364         monitor_printf ("%s\r", paddr_nz (val));
1365     }
1366   if (current_monitor->setreg.term)
1367     {
1368       monitor_debug ("EXP setreg.term\n");
1369       monitor_expect (current_monitor->setreg.term, NULL, 0);
1370       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1371         monitor_printf ("%s\r", paddr_nz (val));
1372       monitor_expect_prompt (NULL, 0);
1373     }
1374   else
1375     monitor_expect_prompt (NULL, 0);
1376   if (current_monitor->setreg.term_cmd)         /* Mode exit required */
1377     {
1378       monitor_debug ("EXP setreg_termcmd\n");
1379       monitor_printf ("%s", current_monitor->setreg.term_cmd);
1380       monitor_expect_prompt (NULL, 0);
1381     }
1382 }                               /* monitor_store_register */
1383
1384 /* Store the remote registers.  */
1385
1386 static void
1387 monitor_store_registers (int regno)
1388 {
1389   if (regno >= 0)
1390     {
1391       monitor_store_register (regno);
1392       return;
1393     }
1394
1395   for (regno = 0; regno < NUM_REGS; regno++)
1396     monitor_store_register (regno);
1397 }
1398
1399 /* Get ready to modify the registers array.  On machines which store
1400    individual registers, this doesn't need to do anything.  On machines
1401    which store all the registers in one fell swoop, this makes sure
1402    that registers contains all the registers from the program being
1403    debugged.  */
1404
1405 static void
1406 monitor_prepare_to_store (void)
1407 {
1408   /* Do nothing, since we can store individual regs */
1409 }
1410
1411 static void
1412 monitor_files_info (struct target_ops *ops)
1413 {
1414   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
1415 }
1416
1417 static int
1418 monitor_write_memory (CORE_ADDR memaddr, char *myaddr, int len)
1419 {
1420   unsigned int val, hostval;
1421   char *cmd;
1422   int i;
1423
1424   monitor_debug ("MON write %d %s\n", len, paddr (memaddr));
1425
1426   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1427     memaddr = ADDR_BITS_REMOVE (memaddr);
1428
1429   /* Use memory fill command for leading 0 bytes.  */
1430
1431   if (current_monitor->fill)
1432     {
1433       for (i = 0; i < len; i++)
1434         if (myaddr[i] != 0)
1435           break;
1436
1437       if (i > 4)                /* More than 4 zeros is worth doing */
1438         {
1439           monitor_debug ("MON FILL %d\n", i);
1440           if (current_monitor->flags & MO_FILL_USES_ADDR)
1441             monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
1442           else
1443             monitor_printf (current_monitor->fill, memaddr, i, 0);
1444
1445           monitor_expect_prompt (NULL, 0);
1446
1447           return i;
1448         }
1449     }
1450
1451 #if 0
1452   /* Can't actually use long longs if VAL is an int (nice idea, though).  */
1453   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1454     {
1455       len = 8;
1456       cmd = current_monitor->setmem.cmdll;
1457     }
1458   else
1459 #endif
1460   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1461     {
1462       len = 4;
1463       cmd = current_monitor->setmem.cmdl;
1464     }
1465   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1466     {
1467       len = 2;
1468       cmd = current_monitor->setmem.cmdw;
1469     }
1470   else
1471     {
1472       len = 1;
1473       cmd = current_monitor->setmem.cmdb;
1474     }
1475
1476   val = extract_unsigned_integer (myaddr, len);
1477
1478   if (len == 4)
1479     {
1480       hostval = *(unsigned int *) myaddr;
1481       monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
1482     }
1483
1484
1485   if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1486     monitor_printf_noecho (cmd, memaddr, val);
1487   else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1488     {
1489
1490       monitor_printf_noecho (cmd, memaddr);
1491
1492       if (current_monitor->setmem.resp_delim)
1493         {
1494           monitor_debug ("EXP setmem.resp_delim");
1495           monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0); 
1496           monitor_printf ("%x\r", val);
1497        }
1498       if (current_monitor->setmem.term)
1499         {
1500           monitor_debug ("EXP setmem.term");
1501           monitor_expect (current_monitor->setmem.term, NULL, 0);
1502           monitor_printf ("%x\r", val);
1503         }
1504       if (current_monitor->setmem.term_cmd)
1505         {                       /* Emit this to get out of the memory editing state */
1506           monitor_printf ("%s", current_monitor->setmem.term_cmd);
1507           /* Drop through to expecting a prompt */
1508         }
1509     }
1510   else
1511     monitor_printf (cmd, memaddr, val);
1512
1513   monitor_expect_prompt (NULL, 0);
1514
1515   return len;
1516 }
1517
1518
1519 static int
1520 monitor_write_even_block (CORE_ADDR memaddr, char *myaddr, int len)
1521 {
1522   unsigned int val;
1523   int written = 0;;
1524   /* Enter the sub mode */
1525   monitor_printf (current_monitor->setmem.cmdl, memaddr);
1526   monitor_expect_prompt (NULL, 0);
1527
1528   while (len)
1529     {
1530       val = extract_unsigned_integer (myaddr, 4);       /* REALLY */
1531       monitor_printf ("%x\r", val);
1532       myaddr += 4;
1533       memaddr += 4;
1534       written += 4;
1535       monitor_debug (" @ %s\n", paddr (memaddr));
1536       /* If we wanted to, here we could validate the address */
1537       monitor_expect_prompt (NULL, 0);
1538     }
1539   /* Now exit the sub mode */
1540   monitor_printf (current_monitor->getreg.term_cmd);
1541   monitor_expect_prompt (NULL, 0);
1542   return written;
1543 }
1544
1545
1546 static int
1547 monitor_write_memory_bytes (CORE_ADDR memaddr, char *myaddr, int len)
1548 {
1549   unsigned char val;
1550   int written = 0;
1551   if (len == 0)
1552     return 0;
1553   /* Enter the sub mode */
1554   monitor_printf (current_monitor->setmem.cmdb, memaddr);
1555   monitor_expect_prompt (NULL, 0);
1556   while (len)
1557     {
1558       val = *myaddr;
1559       monitor_printf ("%x\r", val);
1560       myaddr++;
1561       memaddr++;
1562       written++;
1563       /* If we wanted to, here we could validate the address */
1564       monitor_expect_prompt (NULL, 0);
1565       len--;
1566     }
1567   /* Now exit the sub mode */
1568   monitor_printf (current_monitor->getreg.term_cmd);
1569   monitor_expect_prompt (NULL, 0);
1570   return written;
1571 }
1572
1573
1574 static void
1575 longlongendswap (unsigned char *a)
1576 {
1577   int i, j;
1578   unsigned char x;
1579   i = 0;
1580   j = 7;
1581   while (i < 4)
1582     {
1583       x = *(a + i);
1584       *(a + i) = *(a + j);
1585       *(a + j) = x;
1586       i++, j--;
1587     }
1588 }
1589 /* Format 32 chars of long long value, advance the pointer */
1590 static char *hexlate = "0123456789abcdef";
1591 static char *
1592 longlong_hexchars (unsigned long long value,
1593                    char *outbuff)
1594 {
1595   if (value == 0)
1596     {
1597       *outbuff++ = '0';
1598       return outbuff;
1599     }
1600   else
1601     {
1602       static unsigned char disbuf[8];   /* disassembly buffer */
1603       unsigned char *scan, *limit;      /* loop controls */
1604       unsigned char c, nib;
1605       int leadzero = 1;
1606       scan = disbuf;
1607       limit = scan + 8;
1608       {
1609         unsigned long long *dp;
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   llptr = (unsigned long long *) myaddr;
1647   if (len == 0)
1648     return 0;
1649   monitor_printf (current_monitor->setmem.cmdll, memaddr);
1650   monitor_expect_prompt (NULL, 0);
1651   while (len >= 8)
1652     {
1653       value = *llptr;
1654       endstring = longlong_hexchars (*llptr, hexstage);
1655       *endstring = '\0';        /* NUll terminate for printf */
1656       monitor_printf ("%s\r", hexstage);
1657       llptr++;
1658       memaddr += 8;
1659       written += 8;
1660       /* If we wanted to, here we could validate the address */
1661       monitor_expect_prompt (NULL, 0);
1662       len -= 8;
1663     }
1664   /* Now exit the sub mode */
1665   monitor_printf (current_monitor->getreg.term_cmd);
1666   monitor_expect_prompt (NULL, 0);
1667   return written;
1668 }                               /* */
1669
1670
1671
1672 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1673 /* This is for the large blocks of memory which may occur in downloading.
1674    And for monitors which use interactive entry,
1675    And for monitors which do not have other downloading methods.
1676    Without this, we will end up calling monitor_write_memory many times
1677    and do the entry and exit of the sub mode many times
1678    This currently assumes...
1679    MO_SETMEM_INTERACTIVE
1680    ! MO_NO_ECHO_ON_SETMEM
1681    To use this, the you have to patch the monitor_cmds block with
1682    this function. Otherwise, its not tuned up for use by all
1683    monitor variations.
1684  */
1685
1686 static int
1687 monitor_write_memory_block (CORE_ADDR memaddr, char *myaddr, int len)
1688 {
1689   int written;
1690   written = 0;
1691   /* FIXME: This would be a good place to put the zero test */
1692 #if 1
1693   if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1694     {
1695       return monitor_write_memory_longlongs (memaddr, myaddr, len);
1696     }
1697 #endif
1698 #if 0
1699   if (len > 4)
1700     {
1701       int sublen;
1702       written = monitor_write_even_block (memaddr, myaddr, len);
1703       /* Adjust calling parameters by written amount */
1704       memaddr += written;
1705       myaddr += written;
1706       len -= written;
1707     }
1708 #endif
1709   written = monitor_write_memory_bytes (memaddr, myaddr, len);
1710   return written;
1711 }
1712
1713 /* This is an alternate form of monitor_read_memory which is used for monitors
1714    which can only read a single byte/word/etc. at a time.  */
1715
1716 static int
1717 monitor_read_memory_single (CORE_ADDR memaddr, char *myaddr, int len)
1718 {
1719   unsigned int val;
1720   char membuf[sizeof (int) * 2 + 1];
1721   char *p;
1722   char *cmd;
1723
1724   monitor_debug ("MON read single\n");
1725 #if 0
1726   /* Can't actually use long longs (nice idea, though).  In fact, the
1727      call to strtoul below will fail if it tries to convert a value
1728      that's too big to fit in a long.  */
1729   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1730     {
1731       len = 8;
1732       cmd = current_monitor->getmem.cmdll;
1733     }
1734   else
1735 #endif
1736   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1737     {
1738       len = 4;
1739       cmd = current_monitor->getmem.cmdl;
1740     }
1741   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1742     {
1743       len = 2;
1744       cmd = current_monitor->getmem.cmdw;
1745     }
1746   else
1747     {
1748       len = 1;
1749       cmd = current_monitor->getmem.cmdb;
1750     }
1751
1752   /* Send the examine command.  */
1753
1754   monitor_printf (cmd, memaddr);
1755
1756   /* If RESP_DELIM is specified, we search for that as a leading
1757      delimiter for the memory value.  Otherwise, we just start
1758      searching from the start of the buf.  */
1759
1760   if (current_monitor->getmem.resp_delim)
1761     {
1762       monitor_debug ("EXP getmem.resp_delim\n");
1763       monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1764     }
1765
1766   /* Now, read the appropriate number of hex digits for this loc,
1767      skipping spaces.  */
1768
1769   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1770   if (current_monitor->flags & MO_HEX_PREFIX)
1771     {
1772       int c;
1773
1774       c = readchar (timeout);
1775       while (c == ' ')
1776         c = readchar (timeout);
1777       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1778         ;
1779       else
1780         monitor_error ("monitor_read_memory_single", 
1781                        "bad response from monitor",
1782                        memaddr, 0, NULL, 0);
1783     }
1784
1785   {
1786     int i;
1787     for (i = 0; i < len * 2; i++)
1788       {
1789         int c;
1790
1791         while (1)
1792           {
1793             c = readchar (timeout);
1794             if (isxdigit (c))
1795               break;
1796             if (c == ' ')
1797               continue;
1798             
1799             monitor_error ("monitor_read_memory_single",
1800                            "bad response from monitor",
1801                            memaddr, i, membuf, 0);
1802           }
1803       membuf[i] = c;
1804     }
1805     membuf[i] = '\000';         /* terminate the number */
1806   }
1807
1808 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
1809    present), we will send TERM_CMD if that is present.  In any case, we collect
1810    all of the output into buf, and then wait for the normal prompt.  */
1811
1812   if (current_monitor->getmem.term)
1813     {
1814       monitor_expect (current_monitor->getmem.term, NULL, 0);   /* get response */
1815
1816       if (current_monitor->getmem.term_cmd)
1817         {
1818           monitor_printf (current_monitor->getmem.term_cmd);
1819           monitor_expect_prompt (NULL, 0);
1820         }
1821     }
1822   else
1823     monitor_expect_prompt (NULL, 0);    /* get response */
1824
1825   p = membuf;
1826   val = strtoul (membuf, &p, 16);
1827
1828   if (val == 0 && membuf == p)
1829     monitor_error ("monitor_read_memory_single",
1830                    "bad value from monitor",
1831                    memaddr, 0, membuf, 0);
1832
1833   /* supply register stores in target byte order, so swap here */
1834
1835   store_unsigned_integer (myaddr, len, val);
1836
1837   return len;
1838 }
1839
1840 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1841    memory at MEMADDR.  Returns length moved.  Currently, we do no more
1842    than 16 bytes at a time.  */
1843
1844 static int
1845 monitor_read_memory (CORE_ADDR memaddr, char *myaddr, int len)
1846 {
1847   unsigned int val;
1848   char buf[512];
1849   char *p, *p1;
1850   int resp_len;
1851   int i;
1852   CORE_ADDR dumpaddr;
1853
1854   if (len <= 0)
1855     {
1856       monitor_debug ("Zero length call to monitor_read_memory\n");
1857       return 0;
1858     }
1859
1860   monitor_debug ("MON read block ta(%s) ha(%lx) %d\n",
1861                  paddr_nz (memaddr), (long) myaddr, len);
1862
1863   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1864     memaddr = ADDR_BITS_REMOVE (memaddr);
1865
1866   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1867     return monitor_read_memory_single (memaddr, myaddr, len);
1868
1869   len = min (len, 16);
1870
1871   /* Some dumpers align the first data with the preceeding 16
1872      byte boundary. Some print blanks and start at the
1873      requested boundary. EXACT_DUMPADDR
1874    */
1875
1876   dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1877     ? memaddr : memaddr & ~0x0f;
1878
1879   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
1880   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1881     len = ((memaddr + len) & ~0xf) - memaddr;
1882
1883   /* send the memory examine command */
1884
1885   if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1886     monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
1887   else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1888     monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1889   else
1890     monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1891
1892   /* If TERM is present, we wait for that to show up.  Also, (if TERM
1893      is present), we will send TERM_CMD if that is present.  In any
1894      case, we collect all of the output into buf, and then wait for
1895      the normal prompt.  */
1896
1897   if (current_monitor->getmem.term)
1898     {
1899       resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf);        /* get response */
1900
1901       if (resp_len <= 0)
1902         monitor_error ("monitor_read_memory",
1903                        "excessive response from monitor",
1904                        memaddr, resp_len, buf, 0);
1905
1906       if (current_monitor->getmem.term_cmd)
1907         {
1908           serial_write (monitor_desc, current_monitor->getmem.term_cmd,
1909                         strlen (current_monitor->getmem.term_cmd));
1910           monitor_expect_prompt (NULL, 0);
1911         }
1912     }
1913   else
1914     resp_len = monitor_expect_prompt (buf, sizeof buf);         /* get response */
1915
1916   p = buf;
1917
1918   /* If RESP_DELIM is specified, we search for that as a leading
1919      delimiter for the values.  Otherwise, we just start searching
1920      from the start of the buf.  */
1921
1922   if (current_monitor->getmem.resp_delim)
1923     {
1924       int retval, tmp;
1925       struct re_registers resp_strings;
1926       monitor_debug ("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim);
1927
1928       memset (&resp_strings, 0, sizeof (struct re_registers));
1929       tmp = strlen (p);
1930       retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1931                           &resp_strings);
1932
1933       if (retval < 0)
1934         monitor_error ("monitor_read_memory",
1935                        "bad response from monitor",
1936                        memaddr, resp_len, buf, 0);
1937
1938       p += resp_strings.end[0];
1939 #if 0
1940       p = strstr (p, current_monitor->getmem.resp_delim);
1941       if (!p)
1942         monitor_error ("monitor_read_memory",
1943                        "bad response from monitor",
1944                        memaddr, resp_len, buf, 0);
1945       p += strlen (current_monitor->getmem.resp_delim);
1946 #endif
1947     }
1948   monitor_debug ("MON scanning  %d ,%lx '%s'\n", len, (long) p, p);
1949   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1950     {
1951       char c;
1952       int fetched = 0;
1953       i = len;
1954       c = *p;
1955
1956
1957       while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
1958         {
1959           if (isxdigit (c))
1960             {
1961               if ((dumpaddr >= memaddr) && (i > 0))
1962                 {
1963                   val = fromhex (c) * 16 + fromhex (*(p + 1));
1964                   *myaddr++ = val;
1965                   if (monitor_debug_p || remote_debug)
1966                     fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
1967                   --i;
1968                   fetched++;
1969                 }
1970               ++dumpaddr;
1971               ++p;
1972             }
1973           ++p;                  /* skip a blank or other non hex char */
1974           c = *p;
1975         }
1976       if (fetched == 0)
1977         error ("Failed to read via monitor");
1978       if (monitor_debug_p || remote_debug)
1979         fprintf_unfiltered (gdb_stdlog, "\n");
1980       return fetched;           /* Return the number of bytes actually read */
1981     }
1982   monitor_debug ("MON scanning bytes\n");
1983
1984   for (i = len; i > 0; i--)
1985     {
1986       /* Skip non-hex chars, but bomb on end of string and newlines */
1987
1988       while (1)
1989         {
1990           if (isxdigit (*p))
1991             break;
1992
1993           if (*p == '\000' || *p == '\n' || *p == '\r')
1994             monitor_error ("monitor_read_memory",
1995                            "badly terminated response from monitor",
1996                            memaddr, resp_len, buf, 0);
1997           p++;
1998         }
1999
2000       val = strtoul (p, &p1, 16);
2001
2002       if (val == 0 && p == p1)
2003         monitor_error ("monitor_read_memory",
2004                        "bad value from monitor",
2005                        memaddr, resp_len, buf, 0);
2006
2007       *myaddr++ = val;
2008
2009       if (i == 1)
2010         break;
2011
2012       p = p1;
2013     }
2014
2015   return len;
2016 }
2017
2018 /* Transfer LEN bytes between target address MEMADDR and GDB address
2019    MYADDR.  Returns 0 for success, errno code for failure. TARGET is
2020    unused. */
2021
2022 static int
2023 monitor_xfer_memory (CORE_ADDR memaddr, char *myaddr, int len, int write,
2024                      struct mem_attrib *attrib, struct target_ops *target)
2025 {
2026   int res;
2027
2028   if (write)
2029     {
2030       if (current_monitor->flags & MO_HAS_BLOCKWRITES)
2031         res = monitor_write_memory_block(memaddr, myaddr, len);
2032       else
2033         res = monitor_write_memory(memaddr, myaddr, len);
2034     }
2035   else
2036     {
2037       res = monitor_read_memory(memaddr, myaddr, len);
2038     }
2039
2040   return res;
2041 }
2042
2043 static void
2044 monitor_kill (void)
2045 {
2046   return;                       /* ignore attempts to kill target system */
2047 }
2048
2049 /* All we actually do is set the PC to the start address of exec_bfd, and start
2050    the program at that point.  */
2051
2052 static void
2053 monitor_create_inferior (char *exec_file, char *args, char **env)
2054 {
2055   if (args && (*args != '\000'))
2056     error ("Args are not supported by the monitor.");
2057
2058   first_time = 1;
2059   clear_proceed_status ();
2060   proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
2061 }
2062
2063 /* Clean up when a program exits.
2064    The program actually lives on in the remote processor's RAM, and may be
2065    run again without a download.  Don't leave it full of breakpoint
2066    instructions.  */
2067
2068 static void
2069 monitor_mourn_inferior (void)
2070 {
2071   unpush_target (targ_ops);
2072   generic_mourn_inferior ();    /* Do all the proper things now */
2073 }
2074
2075 /* Tell the monitor to add a breakpoint.  */
2076
2077 static int
2078 monitor_insert_breakpoint (CORE_ADDR addr, char *shadow)
2079 {
2080   int i;
2081   unsigned char *bp;
2082   int bplen;
2083
2084   monitor_debug ("MON inst bkpt %s\n", paddr (addr));
2085   if (current_monitor->set_break == NULL)
2086     error ("No set_break defined for this monitor");
2087
2088   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2089     addr = ADDR_BITS_REMOVE (addr);
2090
2091   /* Determine appropriate breakpoint size for this address.  */
2092   bp = memory_breakpoint_from_pc (&addr, &bplen);
2093
2094   for (i = 0; i < current_monitor->num_breakpoints; i++)
2095     {
2096       if (breakaddr[i] == 0)
2097         {
2098           breakaddr[i] = addr;
2099           monitor_read_memory (addr, shadow, bplen);
2100           monitor_printf (current_monitor->set_break, addr);
2101           monitor_expect_prompt (NULL, 0);
2102           return 0;
2103         }
2104     }
2105
2106   error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
2107 }
2108
2109 /* Tell the monitor to remove a breakpoint.  */
2110
2111 static int
2112 monitor_remove_breakpoint (CORE_ADDR addr, char *shadow)
2113 {
2114   int i;
2115
2116   monitor_debug ("MON rmbkpt %s\n", paddr (addr));
2117   if (current_monitor->clr_break == NULL)
2118     error ("No clr_break defined for this monitor");
2119
2120   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2121     addr = ADDR_BITS_REMOVE (addr);
2122
2123   for (i = 0; i < current_monitor->num_breakpoints; i++)
2124     {
2125       if (breakaddr[i] == addr)
2126         {
2127           breakaddr[i] = 0;
2128           /* some monitors remove breakpoints based on the address */
2129           if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
2130             monitor_printf (current_monitor->clr_break, addr);
2131           else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
2132             monitor_printf (current_monitor->clr_break, i + 1);
2133           else
2134             monitor_printf (current_monitor->clr_break, i);
2135           monitor_expect_prompt (NULL, 0);
2136           return 0;
2137         }
2138     }
2139   fprintf_unfiltered (gdb_stderr,
2140                       "Can't find breakpoint associated with 0x%s\n",
2141                       paddr_nz (addr));
2142   return 1;
2143 }
2144
2145 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2146    an S-record.  Return non-zero if the ACK is received properly.  */
2147
2148 static int
2149 monitor_wait_srec_ack (void)
2150 {
2151   int ch;
2152
2153   if (current_monitor->flags & MO_SREC_ACK_PLUS)
2154     {
2155       return (readchar (timeout) == '+');
2156     }
2157   else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
2158     {
2159       /* Eat two backspaces, a "rotating" char (|/-\), and a space.  */
2160       if ((ch = readchar (1)) < 0)
2161         return 0;
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     }
2169   return 1;
2170 }
2171
2172 /* monitor_load -- download a file. */
2173
2174 static void
2175 monitor_load (char *file, int from_tty)
2176 {
2177   monitor_debug ("MON load\n");
2178
2179   if (current_monitor->load_routine)
2180     current_monitor->load_routine (monitor_desc, file, hashmark);
2181   else
2182     {                           /* The default is ascii S-records */
2183       int n;
2184       unsigned long load_offset;
2185       char buf[128];
2186
2187       /* enable user to specify address for downloading as 2nd arg to load */
2188       n = sscanf (file, "%s 0x%lx", buf, &load_offset);
2189       if (n > 1)
2190         file = buf;
2191       else
2192         load_offset = 0;
2193
2194       monitor_printf (current_monitor->load);
2195       if (current_monitor->loadresp)
2196         monitor_expect (current_monitor->loadresp, NULL, 0);
2197
2198       load_srec (monitor_desc, file, (bfd_vma) load_offset,
2199                  32, SREC_ALL, hashmark,
2200                  current_monitor->flags & MO_SREC_ACK ?
2201                  monitor_wait_srec_ack : NULL);
2202
2203       monitor_expect_prompt (NULL, 0);
2204     }
2205
2206   /* Finally, make the PC point at the start address */
2207   if (exec_bfd)
2208     write_pc (bfd_get_start_address (exec_bfd));
2209
2210   /* There used to be code here which would clear inferior_ptid and
2211      call clear_symtab_users.  None of that should be necessary:
2212      monitor targets should behave like remote protocol targets, and
2213      since generic_load does none of those things, this function
2214      shouldn't either.
2215
2216      Furthermore, clearing inferior_ptid is *incorrect*.  After doing
2217      a load, we still have a valid connection to the monitor, with a
2218      live processor state to fiddle with.  The user can type
2219      `continue' or `jump *start' and make the program run.  If they do
2220      these things, however, GDB will be talking to a running program
2221      while inferior_ptid is null_ptid; this makes things like
2222      reinit_frame_cache very confused.  */
2223 }
2224
2225 static void
2226 monitor_stop (void)
2227 {
2228   monitor_debug ("MON stop\n");
2229   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2230     serial_send_break (monitor_desc);
2231   if (current_monitor->stop)
2232     monitor_printf_noecho (current_monitor->stop);
2233 }
2234
2235 /* Put a COMMAND string out to MONITOR.  Output from MONITOR is placed
2236    in OUTPUT until the prompt is seen. FIXME: We read the characters
2237    ourseleves here cause of a nasty echo.  */
2238
2239 static void
2240 monitor_rcmd (char *command,
2241               struct ui_file *outbuf)
2242 {
2243   char *p;
2244   int resp_len;
2245   char buf[1000];
2246
2247   if (monitor_desc == NULL)
2248     error ("monitor target not open.");
2249
2250   p = current_monitor->prompt;
2251
2252   /* Send the command.  Note that if no args were supplied, then we're
2253      just sending the monitor a newline, which is sometimes useful.  */
2254
2255   monitor_printf ("%s\r", (command ? command : ""));
2256
2257   resp_len = monitor_expect_prompt (buf, sizeof buf);
2258
2259   fputs_unfiltered (buf, outbuf);       /* Output the response */
2260 }
2261
2262 /* Convert hex digit A to a number.  */
2263
2264 #if 0
2265 static int
2266 from_hex (int a)
2267 {
2268   if (a >= '0' && a <= '9')
2269     return a - '0';
2270   if (a >= 'a' && a <= 'f')
2271     return a - 'a' + 10;
2272   if (a >= 'A' && a <= 'F')
2273     return a - 'A' + 10;
2274
2275   error ("Reply contains invalid hex digit 0x%x", a);
2276 }
2277 #endif
2278
2279 char *
2280 monitor_get_dev_name (void)
2281 {
2282   return dev_name;
2283 }
2284
2285 static struct target_ops monitor_ops;
2286
2287 static void
2288 init_base_monitor_ops (void)
2289 {
2290   monitor_ops.to_shortname = NULL;
2291   monitor_ops.to_longname = NULL;
2292   monitor_ops.to_doc = NULL;
2293   monitor_ops.to_open = NULL;
2294   monitor_ops.to_close = monitor_close;
2295   monitor_ops.to_attach = NULL;
2296   monitor_ops.to_post_attach = NULL;
2297   monitor_ops.to_require_attach = NULL;
2298   monitor_ops.to_detach = monitor_detach;
2299   monitor_ops.to_require_detach = NULL;
2300   monitor_ops.to_resume = monitor_resume;
2301   monitor_ops.to_wait = monitor_wait;
2302   monitor_ops.to_post_wait = NULL;
2303   monitor_ops.to_fetch_registers = monitor_fetch_registers;
2304   monitor_ops.to_store_registers = monitor_store_registers;
2305   monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
2306   monitor_ops.to_xfer_memory = monitor_xfer_memory;
2307   monitor_ops.to_files_info = monitor_files_info;
2308   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
2309   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
2310   monitor_ops.to_terminal_init = 0;
2311   monitor_ops.to_terminal_inferior = 0;
2312   monitor_ops.to_terminal_ours_for_output = 0;
2313   monitor_ops.to_terminal_ours = 0;
2314   monitor_ops.to_terminal_info = 0;
2315   monitor_ops.to_kill = monitor_kill;
2316   monitor_ops.to_load = monitor_load;
2317   monitor_ops.to_lookup_symbol = 0;
2318   monitor_ops.to_create_inferior = monitor_create_inferior;
2319   monitor_ops.to_post_startup_inferior = NULL;
2320   monitor_ops.to_acknowledge_created_inferior = NULL;
2321   monitor_ops.to_clone_and_follow_inferior = NULL;
2322   monitor_ops.to_post_follow_inferior_by_clone = NULL;
2323   monitor_ops.to_insert_fork_catchpoint = NULL;
2324   monitor_ops.to_remove_fork_catchpoint = NULL;
2325   monitor_ops.to_insert_vfork_catchpoint = NULL;
2326   monitor_ops.to_remove_vfork_catchpoint = NULL;
2327   monitor_ops.to_has_forked = NULL;
2328   monitor_ops.to_has_vforked = NULL;
2329   monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
2330   monitor_ops.to_post_follow_vfork = NULL;
2331   monitor_ops.to_insert_exec_catchpoint = NULL;
2332   monitor_ops.to_remove_exec_catchpoint = NULL;
2333   monitor_ops.to_has_execd = NULL;
2334   monitor_ops.to_reported_exec_events_per_exec_call = NULL;
2335   monitor_ops.to_has_exited = NULL;
2336   monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2337   monitor_ops.to_can_run = 0;
2338   monitor_ops.to_notice_signals = 0;
2339   monitor_ops.to_thread_alive = 0;
2340   monitor_ops.to_stop = monitor_stop;
2341   monitor_ops.to_rcmd = monitor_rcmd;
2342   monitor_ops.to_pid_to_exec_file = NULL;
2343   monitor_ops.to_stratum = process_stratum;
2344   monitor_ops.DONT_USE = 0;
2345   monitor_ops.to_has_all_memory = 1;
2346   monitor_ops.to_has_memory = 1;
2347   monitor_ops.to_has_stack = 1;
2348   monitor_ops.to_has_registers = 1;
2349   monitor_ops.to_has_execution = 1;
2350   monitor_ops.to_sections = 0;
2351   monitor_ops.to_sections_end = 0;
2352   monitor_ops.to_magic = OPS_MAGIC;
2353 }                               /* init_base_monitor_ops */
2354
2355 /* Init the target_ops structure pointed at by OPS */
2356
2357 void
2358 init_monitor_ops (struct target_ops *ops)
2359 {
2360   if (monitor_ops.to_magic != OPS_MAGIC)
2361     init_base_monitor_ops ();
2362
2363   memcpy (ops, &monitor_ops, sizeof monitor_ops);
2364 }
2365
2366 /* Define additional commands that are usually only used by monitors.  */
2367
2368 void
2369 _initialize_remote_monitors (void)
2370 {
2371   init_base_monitor_ops ();
2372   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
2373                                   (char *) &hashmark,
2374                                   "Set display of activity while downloading a file.\n\
2375 When enabled, a hashmark \'#\' is displayed.",
2376                                   &setlist),
2377                      &showlist);
2378
2379   add_show_from_set
2380     (add_set_cmd ("monitor", no_class, var_zinteger,
2381                   (char *) &monitor_debug_p,
2382                   "Set debugging of remote monitor communication.\n\
2383 When enabled, communication between GDB and the remote monitor\n\
2384 is displayed.", &setdebuglist),
2385      &showdebuglist);
2386 }