gdb/monitor.c

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