gdb/monitor.c

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