gdb/monitor.c

   1 /* Remote debugging interface for boot monitors, for GDB.
   2    Copyright 1990, 1991, 1992, 1993, 1995, 1996
   3    Free Software Foundation, Inc.
   4    Contributed by Cygnus Support.  Written by Rob Savoye for Cygnus.
   5    Resurrected from the ashes by Stu Grossman.
   6
   7 This file is part of GDB.
   8
   9 This program is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2 of the License, or
  12 (at your option) any later version.
  13
  14 This program is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with this program; if not, write to the Free Software
  21 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  22
  23 /* This file was derived from various remote-* modules. It is a collection
  24    of generic support functions so GDB can talk directly to a ROM based
  25    monitor. This saves use from having to hack an exception based handler
  26    into existance, and makes for quick porting.
  27
  28    This module talks to a debug monitor called 'MONITOR', which
  29    We communicate with MONITOR via either a direct serial line, or a TCP
  30    (or possibly TELNET) stream to a terminal multiplexor,
  31    which in turn talks to the target board.  */
  32
  33 /* FIXME 32x64: This code assumes that registers and addresses are at
  34    most 32 bits long.  If they can be larger, you will need to declare
  35    values as LONGEST and use %llx or some such to print values when
  36    building commands to send to the monitor.  Since we don't know of
  37    any actual 64-bit targets with ROM monitors that use this code,
  38    it's not an issue right now.  -sts 4/18/96  */
  39
  40 #include "defs.h"
  41 #include "gdbcore.h"
  42 #include "target.h"
  43 #include "wait.h"
  44 #ifdef ANSI_PROTOTYPES
  45 #include <stdarg.h>
  46 #else
  47 #include <varargs.h>
  48 #endif
  49 #include <signal.h>
  50 #include <ctype.h>
  51 #include "gdb_string.h"
  52 #include <sys/types.h>
  53 #include "command.h"
  54 #include "serial.h"
  55 #include "monitor.h"
  56 #include "gdbcmd.h"
  57 #include "inferior.h"
  58 #include "gnu-regex.h"
  59 #include "dcache.h"
  60 #include "srec.h"
  61
  62 static int readchar PARAMS ((int timeout));
  63
  64 static void monitor_command PARAMS ((char *args, int fromtty));
  65
  66 static void monitor_fetch_register PARAMS ((int regno));
  67 static void monitor_store_register PARAMS ((int regno));
  68
  69 static void monitor_detach PARAMS ((char *args, int from_tty));
  70 static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
  71 static void monitor_interrupt PARAMS ((int signo));
  72 static void monitor_interrupt_twice PARAMS ((int signo));
  73 static void monitor_interrupt_query PARAMS ((void));
  74 static void monitor_wait_cleanup PARAMS ((int old_timeout));
  75
  76 static int monitor_wait PARAMS ((int pid, struct target_waitstatus *status));
  77 static void monitor_fetch_registers PARAMS ((int regno));
  78 static void monitor_store_registers PARAMS ((int regno));
  79 static void monitor_prepare_to_store PARAMS ((void));
  80 static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops *target));
  81 static void monitor_files_info PARAMS ((struct target_ops *ops));
  82 static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
  83 static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
  84 static void monitor_kill PARAMS ((void));
  85 static void monitor_load PARAMS ((char *file, int from_tty));
  86 static void monitor_mourn_inferior PARAMS ((void));
  87 static void monitor_stop PARAMS ((void));
  88 static void monitor_debug PARAMS ((char *prefix, char *string, char *suffix));
  89
  90 static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
  91 static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr,int len));
  92
  93 static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer *pat,
  94                                           char *buf, int buflen));
  95 static int from_hex PARAMS ((int a));
  96 static unsigned long get_hex_word PARAMS ((void));
  97
  98 static struct monitor_ops *current_monitor;
  99
 100 static int hashmark;            /* flag set by "set hash" */
 101
 102 static int timeout = 30;
 103
 104 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
 105
 106 static void (*ofunc)();         /* Old SIGINT signal handler */
 107
 108 /* Descriptor for I/O to remote machine.  Initialize it to NULL so
 109    that monitor_open knows that we don't have a file open when the
 110    program starts.  */
 111
 112 static serial_t monitor_desc = NULL;
 113
 114 /* Pointer to regexp pattern matching data */
 115
 116 static struct re_pattern_buffer register_pattern;
 117 static char register_fastmap[256];
 118
 119 static struct re_pattern_buffer getmem_resp_delim_pattern;
 120 static char getmem_resp_delim_fastmap[256];
 121
 122 static int dump_reg_flag;       /* Non-zero means do a dump_registers cmd when
 123                                    monitor_wait wakes up.  */
 124
 125 static DCACHE *remote_dcache;
 126
 127 /* monitor_debug is like fputs_unfiltered, except it prints special
 128    characters in printable fashion.  */
 129
 130 static void
 131 monitor_debug (prefix, string, suffix)
 132      char *prefix;
 133      char *string;
 134      char *suffix;
 135 {
 136   int ch;
 137
 138   /* print prefix and suffix after each line */
 139   static int new_line=1;
 140   static char *prev_prefix = "";
 141   static char *prev_suffix = "";
 142
 143   /* if the prefix is changing, print the previous suffix, a new line,
 144      and the new prefix */
 145   if (strcmp(prev_prefix, prefix) != 0 && !new_line)
 146     {
 147       fputs_unfiltered (prev_suffix, gdb_stderr);
 148       fputs_unfiltered ("\n", gdb_stderr);
 149       fputs_unfiltered (prefix, gdb_stderr);
 150     }
 151   prev_prefix = prefix;
 152   prev_suffix = suffix;
 153
 154   /* print prefix if last char was a newline*/
 155
 156   if (new_line == 1) {
 157     fputs_unfiltered (prefix, gdb_stderr);
 158     new_line=0;
 159   }
 160   if (strchr(string,'\n'))      /* save state for next call */
 161     new_line=1;
 162
 163   while ((ch = *string++) != '\0')
 164     {
 165       switch (ch) {
 166       default:
 167         if (isprint (ch))
 168           fputc_unfiltered (ch, gdb_stderr);
 169
 170         else
 171           fprintf_unfiltered (gdb_stderr, "\\%03o", ch);
 172
 173         break;
 174
 175       case '\\': fputs_unfiltered ("\\\\",  gdb_stderr);        break;
 176       case '\b': fputs_unfiltered ("\\b",   gdb_stderr);        break;
 177       case '\f': fputs_unfiltered ("\\f",   gdb_stderr);        break;
 178       case '\n': fputs_unfiltered ("\\n",   gdb_stderr);        break;
 179       case '\r': fputs_unfiltered ("\\r",   gdb_stderr);        break;
 180       case '\t': fputs_unfiltered ("\\t",   gdb_stderr);        break;
 181       case '\v': fputs_unfiltered ("\\v",   gdb_stderr);        break;
 182       }
 183     }
 184
 185   if (new_line==1) {    /* print suffix if last char was a newline */
 186     fputs_unfiltered (suffix, gdb_stderr);
 187     fputs_unfiltered ("\n", gdb_stderr);
 188   }
 189 }
 190
 191 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
 192    Works just like printf.  */
 193
 194 void
 195 #ifdef ANSI_PROTOTYPES
 196 monitor_printf_noecho (char *pattern, ...)
 197 #else
 198 monitor_printf_noecho (va_alist)
 199      va_dcl
 200 #endif
 201 {
 202   va_list args;
 203   char sndbuf[2000];
 204   int len;
 205
 206 #if ANSI_PROTOTYPES
 207   va_start (args, pattern);
 208 #else
 209   char *pattern;
 210   va_start (args);
 211   pattern = va_arg (args, char *);
 212 #endif
 213
 214   vsprintf (sndbuf, pattern, args);
 215
 216   if (remote_debug > 0)
 217     monitor_debug ("sent -->", sndbuf, "<--");
 218
 219   len = strlen (sndbuf);
 220
 221   if (len + 1 > sizeof sndbuf)
 222     abort ();
 223
 224   if (SERIAL_WRITE(monitor_desc, sndbuf, len))
 225     fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
 226 }
 227
 228 /* monitor_printf -- Send data to monitor and check the echo.  Works just like
 229    printf.  */
 230
 231 void
 232 #ifdef ANSI_PROTOTYPES
 233 monitor_printf (char *pattern, ...)
 234 #else
 235 monitor_printf (va_alist)
 236      va_dcl
 237 #endif
 238 {
 239   va_list args;
 240   char sndbuf[2000];
 241   int len;
 242
 243 #ifdef ANSI_PROTOTYPES
 244   va_start (args, pattern);
 245 #else
 246   char *pattern;
 247   va_start (args);
 248   pattern = va_arg (args, char *);
 249 #endif
 250
 251   vsprintf (sndbuf, pattern, args);
 252
 253   if (remote_debug > 0)
 254     monitor_debug ("sent -->", sndbuf, "<--");
 255
 256   len = strlen (sndbuf);
 257
 258   if (len + 1 > sizeof sndbuf)
 259     abort ();
 260
 261   if (SERIAL_WRITE(monitor_desc, sndbuf, len))
 262     fprintf_unfiltered (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
 263
 264   /* We used to expect that the next immediate output was the characters we
 265      just output, but sometimes some extra junk appeared before the characters
 266      we expected, like an extra prompt, or a portmaster sending telnet negotiations.
 267      So, just start searching for what we sent, and skip anything unknown.  */
 268   monitor_expect (sndbuf, (char *)0, 0);
 269 }
 270
 271 /* Read a character from the remote system, doing all the fancy
 272    timeout stuff.  */
 273
 274 static int
 275 readchar (timeout)
 276      int timeout;
 277 {
 278   int c;
 279   static enum { last_random, last_nl, last_cr, last_crnl } state = last_random;
 280   int looping;
 281
 282   do
 283     {
 284       looping = 0;
 285       c = SERIAL_READCHAR (monitor_desc, timeout);
 286
 287       if (c >= 0)
 288         {
 289           c &= 0x7f;
 290           if (remote_debug > 0)
 291             {
 292               char buf[2];
 293               buf[0] = c;
 294               buf[1] = '\0';
 295               monitor_debug ("read -->", buf, "<--");
 296             }
 297         }
 298
 299       /* Canonicialize \n\r combinations into one \r */
 300       if ((current_monitor->flags & MO_HANDLE_NL) != 0)
 301         {
 302           if ((c == '\r' && state == last_nl)
 303               || (c == '\n' && state == last_cr))
 304             {
 305               state = last_crnl;
 306               looping = 1;
 307             }
 308           else if (c == '\r')
 309             state = last_cr;
 310           else if (c != '\n')
 311             state = last_random;
 312           else
 313             {
 314               state = last_nl;
 315               c = '\r';
 316             }
 317         }
 318     }
 319   while (looping);
 320
 321   if (c >= 0)
 322     return c;
 323
 324   if (c == SERIAL_TIMEOUT)
 325 #ifdef MAINTENANCE_CMDS
 326     if (in_monitor_wait)        /* Watchdog went off */
 327       {
 328         target_mourn_inferior ();
 329         error ("Watchdog has expired.  Target detached.\n");
 330       }
 331     else
 332 #endif
 333       error ("Timeout reading from remote system.");
 334
 335   perror_with_name ("remote-monitor");
 336 }
 337
 338 /* Scan input from the remote system, until STRING is found.  If BUF is non-
 339    zero, then collect input until we have collected either STRING or BUFLEN-1
 340    chars.  In either case we terminate BUF with a 0.  If input overflows BUF
 341    because STRING can't be found, return -1, else return number of chars in BUF
 342    (minus the terminating NUL).  Note that in the non-overflow case, STRING
 343    will be at the end of BUF.  */
 344
 345 int
 346 monitor_expect (string, buf, buflen)
 347      char *string;
 348      char *buf;
 349      int buflen;
 350 {
 351   char *p = string;
 352   int obuflen = buflen;
 353   int c;
 354
 355   immediate_quit = 1;
 356   while (1)
 357     {
 358       if (buf)
 359         {
 360           if (buflen < 2)
 361             {
 362               *buf = '\000';
 363               immediate_quit = 0;
 364               return -1;
 365             }
 366
 367           c = readchar (timeout);
 368           if (c == '\000')
 369             continue;
 370           *buf++ = c;
 371           buflen--;
 372         }
 373       else
 374         c = readchar (timeout);
 375
 376       /* Don't expect any ^C sent to be echoed */
 377
 378       if (*p == '\003' || c == *p)
 379         {
 380           p++;
 381           if (*p == '\0')
 382             {
 383               immediate_quit = 0;
 384
 385               if (buf)
 386                 {
 387                   *buf++ = '\000';
 388                   return obuflen - buflen;
 389                 }
 390               else
 391                 return 0;
 392             }
 393         }
 394       else
 395         {
 396           p = string;
 397           if (c == *p)
 398             p++;
 399         }
 400     }
 401 }
 402
 403 /* Search for a regexp.  */
 404
 405 static int
 406 monitor_expect_regexp (pat, buf, buflen)
 407      struct re_pattern_buffer *pat;
 408      char *buf;
 409      int buflen;
 410 {
 411   char *mybuf;
 412   char *p;
 413
 414   if (buf)
 415     mybuf = buf;
 416   else
 417     {
 418       mybuf = alloca (1024);
 419       buflen = 1024;
 420     }
 421
 422   p = mybuf;
 423   while (1)
 424     {
 425       int retval;
 426
 427       if (p - mybuf >= buflen)
 428         {                       /* Buffer about to overflow */
 429
 430 /* On overflow, we copy the upper half of the buffer to the lower half.  Not
 431    great, but it usually works... */
 432
 433           memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
 434           p = mybuf + buflen / 2;
 435         }
 436
 437       *p++ = readchar (timeout);
 438
 439       retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
 440       if (retval >= 0)
 441         return 1;
 442     }
 443 }
 444
 445 /* Keep discarding input until we see the MONITOR prompt.
 446
 447    The convention for dealing with the prompt is that you
 448    o give your command
 449    o *then* wait for the prompt.
 450
 451    Thus the last thing that a procedure does with the serial line
 452    will be an monitor_expect_prompt().  Exception:  monitor_resume does not
 453    wait for the prompt, because the terminal is being handed over
 454    to the inferior.  However, the next thing which happens after that
 455    is a monitor_wait which does wait for the prompt.
 456    Note that this includes abnormal exit, e.g. error().  This is
 457    necessary to prevent getting into states from which we can't
 458    recover.  */
 459
 460 int
 461 monitor_expect_prompt (buf, buflen)
 462      char *buf;
 463      int buflen;
 464 {
 465   return monitor_expect (current_monitor->prompt, buf, buflen);
 466 }
 467
 468 /* Get N 32-bit words from remote, each preceded by a space, and put
 469    them in registers starting at REGNO.  */
 470
 471 static unsigned long
 472 get_hex_word ()
 473 {
 474   unsigned long val;
 475   int i;
 476   int ch;
 477
 478   do
 479     ch = readchar (timeout);
 480   while (isspace(ch));
 481
 482   val = from_hex (ch);
 483
 484   for (i = 7; i >= 1; i--)
 485     {
 486       ch = readchar (timeout);
 487       if (!isxdigit (ch))
 488         break;
 489       val = (val << 4) | from_hex (ch);
 490     }
 491
 492   return val;
 493 }
 494
 495 static void
 496 compile_pattern (pattern, compiled_pattern, fastmap)
 497      char *pattern;
 498      struct re_pattern_buffer *compiled_pattern;
 499      char *fastmap;
 500 {
 501   int tmp;
 502   char *val;
 503
 504   compiled_pattern->fastmap = fastmap;
 505
 506   tmp = re_set_syntax (RE_SYNTAX_EMACS);
 507   val = re_compile_pattern (pattern,
 508                             strlen (pattern),
 509                             compiled_pattern);
 510   re_set_syntax (tmp);
 511
 512   if (val)
 513     error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
 514
 515   if (fastmap)
 516     re_compile_fastmap (compiled_pattern);
 517 }
 518
 519 /* Open a connection to a remote debugger. NAME is the filename used
 520    for communication.  */
 521
 522 static char *dev_name;
 523 static struct target_ops *targ_ops;
 524
 525 void
 526 monitor_open (args, mon_ops, from_tty)
 527      char *args;
 528      struct monitor_ops *mon_ops;
 529      int from_tty;
 530 {
 531   char *name;
 532   int i;
 533   char **p;
 534
 535   if (mon_ops->magic != MONITOR_OPS_MAGIC)
 536     error ("Magic number of monitor_ops struct wrong.");
 537
 538   targ_ops = mon_ops->target;
 539   name = targ_ops->to_shortname;
 540
 541   if (!args)
 542     error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
 543 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
 544
 545   target_preopen (from_tty);
 546
 547   /* Setup pattern for register dump */
 548
 549   if (mon_ops->register_pattern)
 550     compile_pattern (mon_ops->register_pattern, &register_pattern,
 551                      register_fastmap);
 552
 553   if (mon_ops->getmem.resp_delim)
 554     compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
 555                      getmem_resp_delim_fastmap);
 556
 557   unpush_target (targ_ops);
 558
 559   if (dev_name)
 560     free (dev_name);
 561   dev_name = strsave (args);
 562
 563   monitor_desc = SERIAL_OPEN (dev_name);
 564
 565   if (!monitor_desc)
 566     perror_with_name (dev_name);
 567
 568   if (baud_rate != -1)
 569     {
 570       if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
 571         {
 572           SERIAL_CLOSE (monitor_desc);
 573           perror_with_name (dev_name);
 574         }
 575     }
 576
 577   SERIAL_RAW (monitor_desc);
 578
 579   SERIAL_FLUSH_INPUT (monitor_desc);
 580
 581   /* some systems only work with 2 stop bits */
 582
 583   SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
 584
 585   current_monitor = mon_ops;
 586
 587   /* See if we can wake up the monitor.  First, try sending a stop sequence,
 588      then send the init strings.  Last, remove all breakpoints.  */
 589
 590   if (current_monitor->stop)
 591     {
 592       monitor_stop ();
 593       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
 594         {
 595         monitor_expect_prompt (NULL, 0);
 596       }
 597     }
 598
 599   /* wake up the monitor and see if it's alive */
 600   for (p = mon_ops->init; *p != NULL; p++)
 601     {
 602       /* Some of the characters we send may not be echoed,
 603          but we hope to get a prompt at the end of it all. */
 604
 605       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
 606         monitor_printf(*p);
 607       else
 608         monitor_printf_noecho (*p);
 609       monitor_expect_prompt (NULL, 0);
 610     }
 611
 612   SERIAL_FLUSH_INPUT (monitor_desc);
 613
 614   /* Remove all breakpoints */
 615
 616   if (mon_ops->clr_all_break)
 617     {
 618       monitor_printf (mon_ops->clr_all_break);
 619       monitor_expect_prompt (NULL, 0);
 620     }
 621
 622   if (from_tty)
 623     printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
 624
 625   push_target (targ_ops);
 626
 627   inferior_pid = 42000;         /* Make run command think we are busy... */
 628
 629   /* Give monitor_wait something to read */
 630
 631   monitor_printf (current_monitor->line_term);
 632
 633   remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
 634
 635   start_remote ();
 636 }
 637
 638 /* Close out all files and local state before this target loses
 639    control.  */
 640
 641 void
 642 monitor_close (quitting)
 643      int quitting;
 644 {
 645   if (monitor_desc)
 646     SERIAL_CLOSE (monitor_desc);
 647   monitor_desc = NULL;
 648 }
 649
 650 /* Terminate the open connection to the remote debugger.  Use this
 651    when you want to detach and do something else with your gdb.  */
 652
 653 static void
 654 monitor_detach (args, from_tty)
 655      char *args;
 656      int from_tty;
 657 {
 658   pop_target ();                /* calls monitor_close to do the real work */
 659   if (from_tty)
 660     printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
 661 }
 662
 663 /* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */
 664
 665 char *
 666 monitor_supply_register (regno, valstr)
 667      int regno;
 668      char *valstr;
 669 {
 670   unsigned int val;
 671   unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
 672   char *p;
 673
 674   val = strtoul (valstr, &p, 16);
 675
 676   if (val == 0 && valstr == p)
 677     error ("monitor_supply_register (%d):  bad value from monitor: %s.",
 678            regno, valstr);
 679
 680   /* supply register stores in target byte order, so swap here */
 681
 682   store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
 683
 684   supply_register (regno, regbuf);
 685
 686   return p;
 687 }
 688
 689 /* Tell the remote machine to resume.  */
 690
 691 static void
 692 monitor_resume (pid, step, sig)
 693      int pid, step;
 694      enum target_signal sig;
 695 {
 696   dcache_flush (remote_dcache);
 697   if (step)
 698     monitor_printf (current_monitor->step);
 699   else
 700     {
 701       monitor_printf (current_monitor->cont);
 702       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
 703         dump_reg_flag = 1;
 704     }
 705 }
 706
 707 /* Parse the output of a register dump command.  A monitor specific
 708    regexp is used to extract individual register descriptions of the
 709    form REG=VAL.  Each description is split up into a name and a value
 710    string which are passed down to monitor specific code.  */
 711
 712 static char *
 713 parse_register_dump (buf, len)
 714      char *buf;
 715      int len;
 716 {
 717   while (1)
 718     {
 719       int regnamelen, vallen;
 720       char *regname, *val;
 721       /* Element 0 points to start of register name, and element 1
 722          points to the start of the register value.  */
 723       struct re_registers register_strings;
 724
 725       if (re_search (&register_pattern, buf, len, 0, len,
 726                      &register_strings) == -1)
 727         break;
 728
 729       regnamelen = register_strings.end[1] - register_strings.start[1];
 730       regname = buf + register_strings.start[1];
 731       vallen = register_strings.end[2] - register_strings.start[2];
 732       val = buf + register_strings.start[2];
 733
 734       current_monitor->supply_register (regname, regnamelen, val, vallen);
 735
 736       buf += register_strings.end[0];
 737       len -= register_strings.end[0];
 738     }
 739 }
 740
 741 /* Send ^C to target to halt it.  Target will respond, and send us a
 742    packet.  */
 743
 744 static void
 745 monitor_interrupt (signo)
 746      int signo;
 747 {
 748   /* If this doesn't work, try more severe steps.  */
 749   signal (signo, monitor_interrupt_twice);
 750
 751   if (remote_debug)
 752     printf_unfiltered ("monitor_interrupt called\n");
 753
 754   target_stop ();
 755 }
 756
 757 /* The user typed ^C twice.  */
 758
 759 static void
 760 monitor_interrupt_twice (signo)
 761      int signo;
 762 {
 763   signal (signo, ofunc);
 764
 765   monitor_interrupt_query ();
 766
 767   signal (signo, monitor_interrupt);
 768 }
 769
 770 /* Ask the user what to do when an interrupt is received.  */
 771
 772 static void
 773 monitor_interrupt_query ()
 774 {
 775   target_terminal_ours ();
 776
 777   if (query ("Interrupted while waiting for the program.\n\
 778 Give up (and stop debugging it)? "))
 779     {
 780       target_mourn_inferior ();
 781       return_to_top_level (RETURN_QUIT);
 782     }
 783
 784   target_terminal_inferior ();
 785 }
 786
 787 static void
 788 monitor_wait_cleanup (old_timeout)
 789      int old_timeout;
 790 {
 791   timeout = old_timeout;
 792   signal (SIGINT, ofunc);
 793   in_monitor_wait = 0;
 794 }
 795
 796 /* Wait until the remote machine stops, then return, storing status in
 797    status just as `wait' would.  */
 798
 799 static int
 800 monitor_wait (pid, status)
 801      int pid;
 802      struct target_waitstatus *status;
 803 {
 804   int old_timeout = timeout;
 805   char buf[1024];
 806   int resp_len;
 807   struct cleanup *old_chain;
 808
 809   status->kind = TARGET_WAITKIND_EXITED;
 810   status->value.integer = 0;
 811
 812   old_chain = make_cleanup (monitor_wait_cleanup, old_timeout);
 813
 814 #ifdef MAINTENANCE_CMDS
 815   in_monitor_wait = 1;
 816   timeout = watchdog > 0 ? watchdog : -1;
 817 #else
 818   timeout = -1;         /* Don't time out -- user program is running. */
 819 #endif
 820
 821   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
 822
 823   do
 824     {
 825       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 826
 827       if (resp_len <= 0)
 828         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
 829     }
 830   while (resp_len < 0);
 831
 832   signal (SIGINT, ofunc);
 833
 834   timeout = old_timeout;
 835
 836   if (dump_reg_flag && current_monitor->dump_registers)
 837     {
 838       dump_reg_flag = 0;
 839
 840       monitor_printf (current_monitor->dump_registers);
 841       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 842     }
 843
 844   if (current_monitor->register_pattern)
 845     parse_register_dump (buf, resp_len);
 846
 847   status->kind = TARGET_WAITKIND_STOPPED;
 848   status->value.sig = TARGET_SIGNAL_TRAP;
 849
 850   discard_cleanups (old_chain);
 851
 852   in_monitor_wait = 0;
 853
 854   return inferior_pid;
 855 }
 856
 857 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
 858    errno value.  */
 859
 860 static void
 861 monitor_fetch_register (regno)
 862      int regno;
 863 {
 864   char *name;
 865   static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
 866   char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
 867   int i;
 868
 869   name = current_monitor->regnames[regno];
 870
 871   if (!name)
 872     {
 873       supply_register (regno, zerobuf);
 874       return;
 875     }
 876
 877   /* send the register examine command */
 878
 879   monitor_printf (current_monitor->getreg.cmd, name);
 880
 881   /* If RESP_DELIM is specified, we search for that as a leading
 882      delimiter for the register value.  Otherwise, we just start
 883      searching from the start of the buf.  */
 884
 885   if (current_monitor->getreg.resp_delim)
 886     monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
 887
 888   /* Read upto the maximum number of hex digits for this register, skipping
 889      spaces, but stop reading if something else is seen.  Some monitors
 890      like to drop leading zeros.  */
 891
 892   for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
 893     {
 894       int c;
 895       c = readchar (timeout);
 896       while (c == ' ')
 897         c = readchar (timeout);
 898
 899       if (!isxdigit (c))
 900         break;
 901
 902       regbuf[i] = c;
 903     }
 904
 905   regbuf[i] = '\000';           /* terminate the number */
 906
 907   /* If TERM is present, we wait for that to show up.  Also, (if TERM
 908      is present), we will send TERM_CMD if that is present.  In any
 909      case, we collect all of the output into buf, and then wait for
 910      the normal prompt.  */
 911
 912   if (current_monitor->getreg.term)
 913     {
 914       monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
 915
 916       if (current_monitor->getreg.term_cmd)
 917         {
 918           monitor_printf (current_monitor->getreg.term_cmd);
 919           monitor_expect_prompt (NULL, 0);
 920         }
 921     }
 922   else
 923     monitor_expect_prompt (NULL, 0); /* get response */
 924
 925   monitor_supply_register (regno, regbuf);
 926 }
 927
 928 /* Read the remote registers into the block regs.  */
 929
 930 static void monitor_dump_regs ()
 931 {
 932   if (current_monitor->dump_registers)
 933     {
 934       char buf[200];
 935       int resp_len;
 936
 937       monitor_printf (current_monitor->dump_registers);
 938       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 939       parse_register_dump (buf, resp_len);
 940     }
 941   else
 942     abort(); /* Need some way to read registers */
 943 }
 944
 945 static void
 946 monitor_fetch_registers (regno)
 947      int regno;
 948 {
 949   if (current_monitor->getreg.cmd)
 950     {
 951       if (regno >= 0)
 952         {
 953           monitor_fetch_register (regno);
 954           return;
 955         }
 956
 957       for (regno = 0; regno < NUM_REGS; regno++)
 958         monitor_fetch_register (regno);
 959     }
 960   else {
 961     monitor_dump_regs ();
 962   }
 963 }
 964
 965 /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
 966
 967 static void
 968 monitor_store_register (regno)
 969      int regno;
 970 {
 971   char *name;
 972   unsigned int val;
 973
 974   name = current_monitor->regnames[regno];
 975   if (!name)
 976     return;
 977
 978   val = read_register (regno);
 979
 980  /* send the register deposit command */
 981
 982   monitor_printf (current_monitor->setreg.cmd, name, val);
 983
 984 /* It's possible that there are actually some monitors out there that
 985    will prompt you when you set a register.  In that case, you may
 986    need to add some code here to deal with TERM and TERM_CMD (see
 987    monitor_fetch_register to get an idea of what's needed...) */
 988
 989   monitor_expect_prompt (NULL, 0);
 990 }
 991
 992 /* Store the remote registers.  */
 993
 994 static void
 995 monitor_store_registers (regno)
 996      int regno;
 997 {
 998   if (regno >= 0)
 999     {
1000       monitor_store_register (regno);
1001       return;
1002     }
1003
1004   for (regno = 0; regno < NUM_REGS; regno++)
1005     monitor_store_register (regno);
1006 }
1007
1008 /* Get ready to modify the registers array.  On machines which store
1009    individual registers, this doesn't need to do anything.  On machines
1010    which store all the registers in one fell swoop, this makes sure
1011    that registers contains all the registers from the program being
1012    debugged.  */
1013
1014 static void
1015 monitor_prepare_to_store ()
1016 {
1017   /* Do nothing, since we can store individual regs */
1018 }
1019
1020 static void
1021 monitor_files_info (ops)
1022      struct target_ops *ops;
1023 {
1024   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
1025 }
1026
1027 static int
1028 monitor_write_memory (memaddr, myaddr, len)
1029      CORE_ADDR memaddr;
1030      char *myaddr;
1031      int len;
1032 {
1033   unsigned int val;
1034   char *cmd;
1035   int i;
1036
1037   /* Use memory fill command for leading 0 bytes.  */
1038
1039   if (current_monitor->fill)
1040     {
1041       for (i = 0; i < len; i++)
1042         if (myaddr[i] != 0)
1043           break;
1044
1045       if (i > 4)                /* More than 4 zeros is worth doing */
1046         {
1047           if (current_monitor->flags & MO_FILL_USES_ADDR)
1048             monitor_printf (current_monitor->fill, memaddr, memaddr + i, 0);
1049           else
1050             monitor_printf (current_monitor->fill, memaddr, i, 0);
1051
1052           monitor_expect_prompt (NULL, 0);
1053
1054           return i;
1055         }
1056     }
1057
1058   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1059     {
1060       len = 8;
1061       cmd = current_monitor->setmem.cmdll;
1062     }
1063   else if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1064     {
1065       len = 4;
1066       cmd = current_monitor->setmem.cmdl;
1067     }
1068   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1069     {
1070       len = 2;
1071       cmd = current_monitor->setmem.cmdw;
1072     }
1073   else
1074     {
1075       len = 1;
1076       cmd = current_monitor->setmem.cmdb;
1077     }
1078
1079   val = extract_unsigned_integer (myaddr, len);
1080
1081   monitor_printf (cmd, memaddr, val);
1082
1083   monitor_expect_prompt (NULL, 0);
1084
1085   return len;
1086 }
1087
1088 /* This is an alternate form of monitor_read_memory which is used for monitors
1089    which can only read a single byte/word/etc. at a time.  */
1090
1091 static int
1092 monitor_read_memory_single (memaddr, myaddr, len)
1093      CORE_ADDR memaddr;
1094      char *myaddr;
1095      int len;
1096 {
1097   unsigned int val;
1098   char membuf[sizeof(int) * 2 + 1];
1099   char *p;
1100   char *cmd;
1101   int i;
1102
1103   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1104     {
1105       len = 8;
1106       cmd = current_monitor->getmem.cmdll;
1107     }
1108   else if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1109     {
1110       len = 4;
1111       cmd = current_monitor->getmem.cmdl;
1112     }
1113   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1114     {
1115       len = 2;
1116       cmd = current_monitor->getmem.cmdw;
1117     }
1118   else
1119     {
1120       len = 1;
1121       cmd = current_monitor->getmem.cmdb;
1122     }
1123
1124 /* Send the examine command.  */
1125
1126   monitor_printf (cmd, memaddr);
1127
1128 /* If RESP_DELIM is specified, we search for that as a leading delimiter for
1129    the register value.  Otherwise, we just start searching from the start of
1130    the buf.  */
1131
1132   if (current_monitor->getmem.resp_delim)
1133     monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1134
1135 /* Now, read the appropriate number of hex digits for this loc, skipping
1136    spaces.  */
1137
1138   for (i = 0; i < len * 2; i++)
1139     {
1140       int c;
1141
1142       while (1)
1143         {
1144           c = readchar (timeout);
1145           if (isxdigit (c))
1146             break;
1147           if (c == ' ')
1148             continue;
1149
1150           error ("monitor_read_memory_single (0x%x):  bad response from monitor: %.*s%c.",
1151                  memaddr, i, membuf, c);
1152         }
1153
1154       membuf[i] = c;
1155     }
1156
1157   membuf[i] = '\000';           /* terminate the number */
1158
1159 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
1160    present), we will send TERM_CMD if that is present.  In any case, we collect
1161    all of the output into buf, and then wait for the normal prompt.  */
1162
1163   if (current_monitor->getmem.term)
1164     {
1165       monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
1166
1167       if (current_monitor->getmem.term_cmd)
1168         {
1169           monitor_printf (current_monitor->getmem.term_cmd);
1170           monitor_expect_prompt (NULL, 0);
1171         }
1172     }
1173   else
1174     monitor_expect_prompt (NULL, 0); /* get response */
1175
1176   p = membuf;
1177   val = strtoul (membuf, &p, 16);
1178
1179   if (val == 0 && membuf == p)
1180     error ("monitor_read_memory_single (0x%x):  bad value from monitor: %s.",
1181            memaddr, membuf);
1182
1183   /* supply register stores in target byte order, so swap here */
1184
1185   store_unsigned_integer (myaddr, len, val);
1186
1187   return len;
1188 }
1189
1190 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory
1191    at MEMADDR.  Returns length moved.  Currently, we only do one byte at a
1192    time.  */
1193
1194 static int
1195 monitor_read_memory (memaddr, myaddr, len)
1196      CORE_ADDR memaddr;
1197      char *myaddr;
1198      int len;
1199 {
1200   unsigned int val;
1201   unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
1202   char buf[512];
1203   char *p, *p1;
1204   char *name;
1205   int resp_len;
1206   int i;
1207
1208   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1209     return monitor_read_memory_single (memaddr, myaddr, len);
1210
1211   len = min (len, 16);
1212
1213 /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
1214   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1215     len = ((memaddr + len) & ~0xf) - memaddr;
1216
1217  /* send the memory examine command */
1218
1219   if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1220     monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len - 1);
1221   else
1222     monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1223
1224 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
1225    present), we will send TERM_CMD if that is present.  In any case, we collect
1226    all of the output into buf, and then wait for the normal prompt.  */
1227
1228   if (current_monitor->getmem.term)
1229     {
1230       resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
1231
1232       if (resp_len <= 0)
1233         error ("monitor_read_memory (0x%x):  excessive response from monitor: %.*s.",
1234                memaddr, resp_len, buf);
1235
1236       if (current_monitor->getmem.term_cmd)
1237         {
1238           SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
1239                         strlen (current_monitor->getmem.term_cmd));
1240           monitor_expect_prompt (NULL, 0);
1241         }
1242     }
1243   else
1244     resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
1245
1246   p = buf;
1247
1248   /* If RESP_DELIM is specified, we search for that as a leading delimiter for
1249      the values.  Otherwise, we just start searching from the start of the buf.
1250    */
1251
1252   if (current_monitor->getmem.resp_delim)
1253     {
1254       int retval, tmp;
1255       struct re_registers resp_strings;
1256
1257       tmp = strlen (p);
1258       retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1259                           &resp_strings);
1260
1261       if (retval < 0)
1262         error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
1263                memaddr, resp_len, buf);
1264
1265       p += resp_strings.end[0];
1266 #if 0
1267       p = strstr (p, current_monitor->getmem.resp_delim);
1268       if (!p)
1269         error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
1270                memaddr, resp_len, buf);
1271       p += strlen (current_monitor->getmem.resp_delim);
1272 #endif
1273     }
1274
1275   for (i = len; i > 0; i--)
1276     {
1277       /* Skip non-hex chars, but bomb on end of string and newlines */
1278
1279       while (1)
1280         {
1281           if (isxdigit (*p))
1282             break;
1283           if (*p == '\000' || *p == '\n' || *p == '\r')
1284             error ("monitor_read_memory (0x%x):  badly terminated response from monitor: %.*s", memaddr, resp_len, buf);
1285           p++;
1286         }
1287
1288       val = strtoul (p, &p1, 16);
1289
1290       if (val == 0 && p == p1)
1291         error ("monitor_read_memory (0x%x):  bad value from monitor: %.*s.", memaddr,
1292                resp_len, buf);
1293
1294       *myaddr++ = val;
1295
1296       if (i == 1)
1297         break;
1298
1299       p = p1;
1300     }
1301
1302   return len;
1303 }
1304
1305 static int
1306 monitor_xfer_memory (memaddr, myaddr, len, write, target)
1307      CORE_ADDR memaddr;
1308      char *myaddr;
1309      int len;
1310      int write;
1311      struct target_ops *target;         /* ignored */
1312 {
1313   return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
1314 }
1315
1316 static void
1317 monitor_kill ()
1318 {
1319   return;               /* ignore attempts to kill target system */
1320 }
1321
1322 /* All we actually do is set the PC to the start address of exec_bfd, and start
1323    the program at that point.  */
1324
1325 static void
1326 monitor_create_inferior (exec_file, args, env)
1327      char *exec_file;
1328      char *args;
1329      char **env;
1330 {
1331   if (args && (*args != '\000'))
1332     error ("Args are not supported by the monitor.");
1333
1334   clear_proceed_status ();
1335   proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
1336 }
1337
1338 /* Clean up when a program exits.
1339    The program actually lives on in the remote processor's RAM, and may be
1340    run again without a download.  Don't leave it full of breakpoint
1341    instructions.  */
1342
1343 static void
1344 monitor_mourn_inferior ()
1345 {
1346   unpush_target (targ_ops);
1347   generic_mourn_inferior ();    /* Do all the proper things now */
1348 }
1349
1350 #define NUM_MONITOR_BREAKPOINTS 8
1351
1352 static CORE_ADDR breakaddr[NUM_MONITOR_BREAKPOINTS] = {0};
1353
1354 /* Tell the monitor to add a breakpoint.  */
1355
1356 static int
1357 monitor_insert_breakpoint (addr, shadow)
1358      CORE_ADDR addr;
1359      char *shadow;
1360 {
1361   int i;
1362   static unsigned char break_insn[] = BREAKPOINT;
1363
1364   for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
1365     {
1366       if (breakaddr[i] == 0)
1367         {
1368           breakaddr[i] = addr;
1369           monitor_read_memory (addr, shadow, sizeof (break_insn));
1370           monitor_printf (current_monitor->set_break, addr);
1371           monitor_expect_prompt (NULL, 0);
1372           return 0;
1373         }
1374     }
1375
1376   error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS);
1377 }
1378
1379 /* Tell the monitor to remove a breakpoint.  */
1380
1381 static int
1382 monitor_remove_breakpoint (addr, shadow)
1383      CORE_ADDR addr;
1384      char *shadow;
1385 {
1386   int i;
1387
1388   for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
1389     {
1390       if (breakaddr[i] == addr)
1391         {
1392           breakaddr[i] = 0;
1393           /* some monitors remove breakpoints based on the address */
1394           if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
1395             monitor_printf (current_monitor->clr_break, addr);
1396           else
1397             monitor_printf (current_monitor->clr_break, i);
1398           monitor_expect_prompt (NULL, 0);
1399           return 0;
1400         }
1401     }
1402   fprintf_unfiltered (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
1403   return 1;
1404 }
1405
1406 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
1407    an S-record.  Return non-zero if the ACK is received properly.  */
1408
1409 static int
1410 monitor_wait_srec_ack ()
1411 {
1412   /* FIXME: eventually we'll want to be able to handle acknowledgements
1413      of something other than a '+' character.  Right now this is only
1414      going to work for EST visionICE.  */
1415   return readchar (timeout) == '+';
1416 }
1417
1418 /* monitor_load -- download a file. */
1419
1420 static void
1421 monitor_load (file, from_tty)
1422     char *file;
1423     int  from_tty;
1424 {
1425   dcache_flush (remote_dcache);
1426
1427   if (current_monitor->load_routine)
1428     current_monitor->load_routine (monitor_desc, file, hashmark);
1429   else
1430     {                           /* The default is ascii S-records */
1431       monitor_printf (current_monitor->load);
1432       if (current_monitor->loadresp)
1433         monitor_expect (current_monitor->loadresp, NULL, 0);
1434
1435       load_srec (monitor_desc, file, 32, SREC_ALL, hashmark,
1436                  current_monitor->flags & MO_SREC_ACK ?
1437                    monitor_wait_srec_ack : NULL);
1438
1439       monitor_expect_prompt (NULL, 0);
1440     }
1441
1442 /* Finally, make the PC point at the start address */
1443
1444   if (exec_bfd)
1445     write_pc (bfd_get_start_address (exec_bfd));
1446
1447   inferior_pid = 0;             /* No process now */
1448
1449 /* This is necessary because many things were based on the PC at the time that
1450    we attached to the monitor, which is no longer valid now that we have loaded
1451    new code (and just changed the PC).  Another way to do this might be to call
1452    normal_stop, except that the stack may not be valid, and things would get
1453    horribly confused... */
1454
1455   clear_symtab_users ();
1456 }
1457
1458 static void
1459 monitor_stop ()
1460 {
1461   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
1462     SERIAL_SEND_BREAK (monitor_desc);
1463   if (current_monitor->stop)
1464     monitor_printf_noecho (current_monitor->stop);
1465 }
1466
1467 /* Put a command string, in args, out to MONITOR.  Output from MONITOR
1468    is placed on the users terminal until the prompt is seen. FIXME: We
1469    read the characters ourseleves here cause of a nasty echo.  */
1470
1471 static void
1472 monitor_command (args, from_tty)
1473      char *args;
1474      int from_tty;
1475 {
1476   char *p;
1477   int resp_len;
1478   char buf[1000];
1479
1480   if (monitor_desc == NULL)
1481     error ("monitor target not open.");
1482
1483   p = current_monitor->prompt;
1484
1485   /* Send the command.  Note that if no args were supplied, then we're
1486      just sending the monitor a newline, which is sometimes useful.  */
1487
1488   monitor_printf ("%s\r", (args ? args : ""));
1489
1490   resp_len = monitor_expect_prompt (buf, sizeof buf);
1491
1492   fputs_unfiltered (buf, gdb_stdout); /* Output the response */
1493 }
1494
1495 /* Convert hex digit A to a number.  */
1496
1497 static int
1498 from_hex (a)
1499      int a;
1500 {
1501   if (a >= '0' && a <= '9')
1502     return a - '0';
1503   if (a >= 'a' && a <= 'f')
1504     return a - 'a' + 10;
1505   if (a >= 'A' && a <= 'F')
1506     return a - 'A' + 10;
1507
1508   error ("Reply contains invalid hex digit 0x%x", a);
1509 }
1510
1511 static struct target_ops monitor_ops =
1512 {
1513   NULL,                         /* to_shortname */
1514   NULL,                         /* to_longname */
1515   NULL,                         /* to_doc */
1516   NULL,                         /* to_open */
1517   monitor_close,                /* to_close */
1518   NULL,                         /* to_attach */
1519   monitor_detach,               /* to_detach */
1520   monitor_resume,               /* to_resume */
1521   monitor_wait,                 /* to_wait */
1522   monitor_fetch_registers,      /* to_fetch_registers */
1523   monitor_store_registers,      /* to_store_registers */
1524   monitor_prepare_to_store,     /* to_prepare_to_store */
1525   monitor_xfer_memory,          /* to_xfer_memory */
1526   monitor_files_info,           /* to_files_info */
1527   monitor_insert_breakpoint,    /* to_insert_breakpoint */
1528   monitor_remove_breakpoint,    /* to_remove_breakpoint */
1529   0,                            /* to_terminal_init */
1530   0,                            /* to_terminal_inferior */
1531   0,                            /* to_terminal_ours_for_output */
1532   0,                            /* to_terminal_ours */
1533   0,                            /* to_terminal_info */
1534   monitor_kill,                 /* to_kill */
1535   monitor_load,                 /* to_load */
1536   0,                            /* to_lookup_symbol */
1537   monitor_create_inferior,      /* to_create_inferior */
1538   monitor_mourn_inferior,       /* to_mourn_inferior */
1539   0,                            /* to_can_run */
1540   0,                            /* to_notice_signals */
1541   0,                            /* to_thread_alive */
1542   monitor_stop,                 /* to_stop */
1543   process_stratum,              /* to_stratum */
1544   0,                            /* to_next */
1545   1,                            /* to_has_all_memory */
1546   1,                            /* to_has_memory */
1547   1,                            /* to_has_stack */
1548   1,                            /* to_has_registers */
1549   1,                            /* to_has_execution */
1550   0,                            /* sections */
1551   0,                            /* sections_end */
1552   OPS_MAGIC                     /* to_magic */
1553 };
1554
1555 /* Init the target_ops structure pointed at by OPS */
1556
1557 void
1558 init_monitor_ops (ops)
1559      struct target_ops *ops;
1560 {
1561   memcpy (ops, &monitor_ops, sizeof monitor_ops);
1562 }
1563
1564 /* Define additional commands that are usually only used by monitors.  */
1565
1566 void
1567 _initialize_remote_monitors ()
1568 {
1569   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
1570                                   (char *)&hashmark,
1571                                   "Set display of activity while downloading a file.\n\
1572 When enabled, a hashmark \'#\' is displayed.",
1573                                   &setlist),
1574                      &showlist);
1575
1576   add_com ("monitor", class_obscure, monitor_command,
1577            "Send a command to the debug monitor.");
1578 }