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       memset (&register_strings, 0, sizeof (struct re_registers));
 851
 852       if (re_search (&register_pattern, buf, len, 0, len,
 853                      &register_strings) == -1)
 854         break;
 855
 856       regnamelen = register_strings.end[1] - register_strings.start[1];
 857       regname = buf + register_strings.start[1];
 858       vallen = register_strings.end[2] - register_strings.start[2];
 859       val = buf + register_strings.start[2];
 860
 861       current_monitor->supply_register (regname, regnamelen, val, vallen);
 862
 863       buf += register_strings.end[0];
 864       len -= register_strings.end[0];
 865     }
 866 }
 867
 868 /* Send ^C to target to halt it.  Target will respond, and send us a
 869    packet.  */
 870
 871 static void
 872 monitor_interrupt (signo)
 873      int signo;
 874 {
 875   /* If this doesn't work, try more severe steps.  */
 876   signal (signo, monitor_interrupt_twice);
 877
 878   if (remote_debug)
 879     printf_unfiltered ("monitor_interrupt called\n");
 880
 881   target_stop ();
 882 }
 883
 884 /* The user typed ^C twice.  */
 885
 886 static void
 887 monitor_interrupt_twice (signo)
 888      int signo;
 889 {
 890   signal (signo, ofunc);
 891
 892   monitor_interrupt_query ();
 893
 894   signal (signo, monitor_interrupt);
 895 }
 896
 897 /* Ask the user what to do when an interrupt is received.  */
 898
 899 static void
 900 monitor_interrupt_query ()
 901 {
 902   target_terminal_ours ();
 903
 904   if (query ("Interrupted while waiting for the program.\n\
 905 Give up (and stop debugging it)? "))
 906     {
 907       target_mourn_inferior ();
 908       return_to_top_level (RETURN_QUIT);
 909     }
 910
 911   target_terminal_inferior ();
 912 }
 913
 914 static void
 915 monitor_wait_cleanup (old_timeout)
 916      void *old_timeout;
 917 {
 918   timeout = *(int*)old_timeout;
 919   signal (SIGINT, ofunc);
 920   in_monitor_wait = 0;
 921 }
 922
 923
 924
 925 void monitor_wait_filter(char * buf,
 926                          int bufmax,
 927                          int * ext_resp_len,
 928                          struct target_waitstatus * status
 929                          )
 930 {
 931   int resp_len ;
 932   do
 933     {
 934       resp_len = monitor_expect_prompt (buf, bufmax);
 935       * ext_resp_len =resp_len ;
 936
 937       if (resp_len <= 0)
 938         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
 939     }
 940   while (resp_len < 0);
 941
 942   /* Print any output characters that were preceded by ^O.  */
 943   /* FIXME - This would be great as a user settabgle flag */
 944   if (remote_debug ||
 945       current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
 946     {
 947       int i;
 948
 949       for (i = 0; i < resp_len - 1; i++)
 950         if (buf[i] == 0x0f)
 951           putchar_unfiltered (buf[++i]);
 952     }
 953 }
 954
 955
 956
 957 /* Wait until the remote machine stops, then return, storing status in
 958    status just as `wait' would.  */
 959
 960 static int
 961 monitor_wait (pid, status)
 962      int pid;
 963      struct target_waitstatus *status;
 964 {
 965   int old_timeout = timeout;
 966   char buf[1024];
 967   int resp_len;
 968   struct cleanup *old_chain;
 969
 970   status->kind = TARGET_WAITKIND_EXITED;
 971   status->value.integer = 0;
 972
 973   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
 974   RDEBUG(("MON wait\n"))
 975
 976 #if 0 /* MAINTENANCE_CMDS */
 977     /* This is somthing other than a maintenance command */
 978   in_monitor_wait = 1;
 979   timeout = watchdog > 0 ? watchdog : -1;
 980 #else
 981   timeout = -1;         /* Don't time out -- user program is running. */
 982 #endif
 983
 984   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
 985
 986   if (current_monitor->wait_filter)
 987     (*current_monitor->wait_filter)(buf,sizeof (buf),&resp_len,status) ;
 988   else          monitor_wait_filter(buf,sizeof (buf),&resp_len,status) ;
 989
 990 #if 0 /* Transferred to monitor wait filter */
 991   do
 992     {
 993       resp_len = monitor_expect_prompt (buf, sizeof (buf));
 994
 995       if (resp_len <= 0)
 996         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
 997     }
 998   while (resp_len < 0);
 999
1000   /* Print any output characters that were preceded by ^O.  */
1001   /* FIXME - This would be great as a user settabgle flag */
1002   if (remote_debug ||
1003       current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1004     {
1005       int i;
1006
1007       for (i = 0; i < resp_len - 1; i++)
1008         if (buf[i] == 0x0f)
1009           putchar_unfiltered (buf[++i]);
1010     }
1011 #endif
1012
1013   signal (SIGINT, ofunc);
1014
1015   timeout = old_timeout;
1016 #if 0
1017   if (dump_reg_flag && current_monitor->dump_registers)
1018     {
1019       dump_reg_flag = 0;
1020       monitor_printf (current_monitor->dump_registers);
1021       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1022     }
1023
1024   if (current_monitor->register_pattern)
1025     parse_register_dump (buf, resp_len);
1026 #else
1027   RDEBUG(("Wait fetching registers after stop\n")) ;
1028   monitor_dump_regs() ;
1029 #endif
1030
1031   status->kind = TARGET_WAITKIND_STOPPED;
1032   status->value.sig = TARGET_SIGNAL_TRAP;
1033
1034   discard_cleanups (old_chain);
1035
1036   in_monitor_wait = 0;
1037
1038   return inferior_pid;
1039 }
1040
1041 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1042    errno value.  */
1043
1044 static void
1045 monitor_fetch_register (regno)
1046      int regno;
1047 {
1048   char *name;
1049   static char zerobuf[MAX_REGISTER_RAW_SIZE] = {0};
1050   char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
1051   int i;
1052
1053   name = current_monitor->regnames[regno];
1054   RDEBUG(("MON fetchreg %d '%s'\n",regno,name))
1055
1056   if (!name || (*name == '\0'))
1057     { RDEBUG(("No register known for %d\n",regno))
1058       supply_register (regno, zerobuf);
1059       return;
1060     }
1061
1062   /* send the register examine command */
1063
1064   monitor_printf (current_monitor->getreg.cmd, name);
1065
1066   /* If RESP_DELIM is specified, we search for that as a leading
1067      delimiter for the register value.  Otherwise, we just start
1068      searching from the start of the buf.  */
1069
1070   if (current_monitor->getreg.resp_delim)
1071     {
1072       RDEBUG(("EXP getreg.resp_delim\n"))
1073       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1074       /* Handle case of first 32 registers listed in pairs.  */
1075       if (current_monitor->flags & MO_32_REGS_PAIRED
1076           && regno & 1 == 1 && regno < 32)
1077         { RDEBUG(("EXP getreg.resp_delim\n")) ;
1078           monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1079         }
1080     }
1081
1082   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1083   if (current_monitor->flags & MO_HEX_PREFIX)
1084     {
1085       int c;
1086       c = readchar (timeout);
1087       while (c == ' ')
1088         c = readchar (timeout);
1089       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1090         ;
1091       else
1092           error ("Bad value returned from monitor while fetching register %x.",
1093                  regno);
1094     }
1095
1096   /* Read upto the maximum number of hex digits for this register, skipping
1097      spaces, but stop reading if something else is seen.  Some monitors
1098      like to drop leading zeros.  */
1099
1100   for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
1101     {
1102       int c;
1103       c = readchar (timeout);
1104       while (c == ' ')
1105         c = readchar (timeout);
1106
1107       if (!isxdigit (c))
1108         break;
1109
1110       regbuf[i] = c;
1111     }
1112
1113   regbuf[i] = '\000';           /* terminate the number */
1114   RDEBUG(("REGVAL '%s'\n",regbuf)) ;
1115
1116   /* If TERM is present, we wait for that to show up.  Also, (if TERM
1117      is present), we will send TERM_CMD if that is present.  In any
1118      case, we collect all of the output into buf, and then wait for
1119      the normal prompt.  */
1120
1121   if (current_monitor->getreg.term)
1122     {
1123       RDEBUG(("EXP getreg.term\n"))
1124       monitor_expect (current_monitor->getreg.term, NULL, 0); /* get response */
1125     }
1126
1127   if (current_monitor->getreg.term_cmd)
1128     { RDEBUG(("EMIT getreg.term.cmd\n"))
1129         monitor_printf (current_monitor->getreg.term_cmd);
1130     }
1131   if (! current_monitor->getreg.term ||    /* Already expected or */
1132       current_monitor->getreg.term_cmd)    /* ack expected */
1133     monitor_expect_prompt (NULL, 0); /* get response */
1134
1135   monitor_supply_register (regno, regbuf);
1136 }
1137
1138 /* Sometimes, it takes several commands to dump the registers */
1139 /* This is a primitive for use by variations of monitor interfaces in
1140    case they need to compose the operation.
1141    */
1142 int monitor_dump_reg_block(char * block_cmd)
1143 {
1144   char buf[1024];
1145   int resp_len;
1146   monitor_printf (block_cmd);
1147   resp_len = monitor_expect_prompt (buf, sizeof (buf));
1148   parse_register_dump (buf, resp_len);
1149   return 1 ;
1150 }
1151
1152
1153 /* Read the remote registers into the block regs.  */
1154 /* Call the specific function if it has been provided */
1155
1156 static void
1157 monitor_dump_regs ()
1158 {
1159   char buf[1024];
1160   int resp_len;
1161   if (current_monitor->dumpregs)
1162      (*(current_monitor->dumpregs))() ; /* call supplied function */
1163   else
1164     if (current_monitor->dump_registers) /* default version */
1165     { monitor_printf (current_monitor->dump_registers);
1166       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1167       parse_register_dump (buf, resp_len);
1168     }
1169   else
1170     abort(); /* Need some way to read registers */
1171 }
1172
1173 static void
1174 monitor_fetch_registers (regno)
1175      int regno;
1176 {
1177   RDEBUG(("MON fetchregs\n")) ;
1178   if (current_monitor->getreg.cmd)
1179     {
1180       if (regno >= 0)
1181         {
1182           monitor_fetch_register (regno);
1183           return;
1184         }
1185
1186       for (regno = 0; regno < NUM_REGS; regno++)
1187         monitor_fetch_register (regno);
1188     }
1189   else {
1190     monitor_dump_regs ();
1191   }
1192 }
1193
1194 /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
1195
1196 static void
1197 monitor_store_register (regno)
1198      int regno;
1199 {
1200   char *name;
1201   unsigned int val;
1202
1203   name = current_monitor->regnames[regno];
1204   if (!name || (*name == '\0'))
1205     { RDEBUG(("MON Cannot store unknown register\n"))
1206       return;
1207     }
1208
1209   val = read_register (regno);
1210   RDEBUG(("MON storeg %d %08x\n",regno,(unsigned int)val))
1211
1212   /* send the register deposit command */
1213
1214   if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1215     monitor_printf (current_monitor->setreg.cmd, val, name);
1216   else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1217     monitor_printf (current_monitor->setreg.cmd, name);
1218   else
1219     monitor_printf (current_monitor->setreg.cmd, name, val);
1220
1221   if (current_monitor->setreg.term)
1222     { RDEBUG(("EXP setreg.term\n"))
1223       monitor_expect (current_monitor->setreg.term, NULL, 0);
1224       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1225         monitor_printf ("%x\r", val);
1226       monitor_expect_prompt (NULL, 0);
1227     }
1228   else
1229     monitor_expect_prompt (NULL, 0);
1230   if (current_monitor->setreg.term_cmd) /* Mode exit required */
1231     { RDEBUG(("EXP setreg_termcmd\n")) ;
1232       monitor_printf("%s",current_monitor->setreg.term_cmd) ;
1233       monitor_expect_prompt(NULL,0) ;
1234     }
1235 } /* monitor_store_register */
1236
1237 /* Store the remote registers.  */
1238
1239 static void
1240 monitor_store_registers (regno)
1241      int regno;
1242 {
1243   if (regno >= 0)
1244     {
1245       monitor_store_register (regno);
1246       return;
1247     }
1248
1249   for (regno = 0; regno < NUM_REGS; regno++)
1250     monitor_store_register (regno);
1251 }
1252
1253 /* Get ready to modify the registers array.  On machines which store
1254    individual registers, this doesn't need to do anything.  On machines
1255    which store all the registers in one fell swoop, this makes sure
1256    that registers contains all the registers from the program being
1257    debugged.  */
1258
1259 static void
1260 monitor_prepare_to_store ()
1261 {
1262   /* Do nothing, since we can store individual regs */
1263 }
1264
1265 static void
1266 monitor_files_info (ops)
1267      struct target_ops *ops;
1268 {
1269   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
1270 }
1271
1272 static int
1273 monitor_write_memory (memaddr, myaddr, len)
1274      CORE_ADDR memaddr;
1275      char *myaddr;
1276      int len;
1277 {
1278   unsigned int val, hostval ;
1279   char *cmd;
1280   int i;
1281
1282   RDEBUG(("MON write %d %08x\n",len,(unsigned long)memaddr))
1283
1284   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1285     memaddr = ADDR_BITS_REMOVE (memaddr);
1286
1287   /* Use memory fill command for leading 0 bytes.  */
1288
1289   if (current_monitor->fill)
1290     {
1291       for (i = 0; i < len; i++)
1292         if (myaddr[i] != 0)
1293           break;
1294
1295       if (i > 4)                /* More than 4 zeros is worth doing */
1296         {
1297           RDEBUG(("MON FILL %d\n",i))
1298             if (current_monitor->flags & MO_FILL_USES_ADDR)
1299               monitor_printf (current_monitor->fill, memaddr, (memaddr + i)-1, 0);
1300             else
1301               monitor_printf (current_monitor->fill, memaddr, i, 0);
1302
1303           monitor_expect_prompt (NULL, 0);
1304
1305           return i;
1306         }
1307     }
1308
1309 #if 0
1310   /* Can't actually use long longs if VAL is an int (nice idea, though).  */
1311   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1312     {
1313       len = 8;
1314       cmd = current_monitor->setmem.cmdll;
1315     }
1316   else
1317 #endif
1318   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1319     {
1320       len = 4;
1321       cmd = current_monitor->setmem.cmdl;
1322     }
1323   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1324     {
1325       len = 2;
1326       cmd = current_monitor->setmem.cmdw;
1327     }
1328   else
1329     {
1330       len = 1;
1331       cmd = current_monitor->setmem.cmdb;
1332     }
1333
1334   val = extract_unsigned_integer (myaddr, len);
1335
1336   if (len == 4)
1337     { hostval = * (unsigned int *) myaddr ;
1338       RDEBUG(("Hostval(%08x) val(%08x)\n",hostval,val)) ;
1339     }
1340
1341
1342   if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1343     monitor_printf_noecho (cmd, memaddr, val);
1344   else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1345     {
1346
1347       monitor_printf_noecho (cmd, memaddr);
1348
1349       if (current_monitor->setmem.term)
1350         { RDEBUG(("EXP setmem.term")) ;
1351           monitor_expect (current_monitor->setmem.term, NULL, 0);
1352           monitor_printf ("%x\r", val);
1353         }
1354       if (current_monitor->setmem.term_cmd)
1355         { /* Emit this to get out of the memory editing state */
1356           monitor_printf("%s",current_monitor->setmem.term_cmd) ;
1357           /* Drop through to expecting a prompt */
1358         }
1359     }
1360   else
1361     monitor_printf (cmd, memaddr, val);
1362
1363   monitor_expect_prompt (NULL, 0);
1364
1365   return len;
1366 }
1367
1368
1369 static int
1370 monitor_write_even_block(memaddr,myaddr,len)
1371      CORE_ADDR memaddr ;
1372      char * myaddr ;
1373      int len ;
1374 {
1375   unsigned int val ;
1376   int written = 0 ;;
1377   /* Enter the sub mode */
1378   monitor_printf(current_monitor->setmem.cmdl,memaddr) ;
1379   monitor_expect_prompt(NULL,0) ;
1380
1381   while (len)
1382     {
1383       val = extract_unsigned_integer(myaddr,4) ; /* REALLY */
1384       monitor_printf("%x\r",val) ;
1385       myaddr += 4 ;
1386       memaddr += 4 ;
1387       written += 4 ;
1388       RDEBUG((" @ %08x\n",memaddr))
1389       /* If we wanted to, here we could validate the address */
1390       monitor_expect_prompt(NULL,0) ;
1391     }
1392   /* Now exit the sub mode */
1393   monitor_printf (current_monitor->getreg.term_cmd);
1394   monitor_expect_prompt(NULL,0) ;
1395   return written ;
1396 }
1397
1398
1399 static int monitor_write_memory_bytes(memaddr,myaddr,len)
1400      CORE_ADDR memaddr ;
1401      char * myaddr ;
1402      int len ;
1403 {
1404   unsigned char val ;
1405   int written = 0 ;
1406   if (len == 0) return 0 ;
1407   /* Enter the sub mode */
1408   monitor_printf(current_monitor->setmem.cmdb,memaddr) ;
1409   monitor_expect_prompt(NULL,0) ;
1410   while (len)
1411     {
1412       val = *myaddr ;
1413       monitor_printf("%x\r",val) ;
1414       myaddr++ ;
1415       memaddr++ ;
1416       written++ ;
1417       /* If we wanted to, here we could validate the address */
1418       monitor_expect_prompt(NULL,0) ;
1419       len-- ;
1420     }
1421   /* Now exit the sub mode */
1422   monitor_printf (current_monitor->getreg.term_cmd);
1423   monitor_expect_prompt(NULL,0) ;
1424   return written ;
1425 }
1426
1427
1428 static void
1429 longlongendswap (unsigned char * a)
1430 {
1431   int i,j ;
1432   unsigned char x ;
1433   i = 0 ; j = 7 ;
1434   while (i < 4)
1435     { x = *(a+i) ;
1436       *(a+i) = *(a+j) ;
1437       *(a+j) = x ;
1438       i++ , j-- ;
1439     }
1440 }
1441 /* Format 32 chars of long long value, advance the pointer */
1442 static char * hexlate = "0123456789abcdef" ;
1443 static char * longlong_hexchars(unsigned long long value,
1444                                  char * outbuff )
1445 {
1446   if (value == 0) { *outbuff++ = '0' ; return outbuff ; }
1447   else
1448     { static unsigned char disbuf[8] ; /* disassembly buffer */
1449       unsigned char * scan , * limit ; /* loop controls */
1450       unsigned char c , nib ;
1451       int leadzero = 1 ;
1452       scan = disbuf ; limit = scan + 8 ;
1453       { unsigned long long * dp ;
1454         dp = (unsigned long long *) scan ;
1455         *dp = value ;
1456       }
1457       longlongendswap(disbuf) ; /* FIXME: ONly on big endian hosts */
1458       while (scan < limit)
1459         { c = *scan++ ; /* a byte of our long long value */
1460           if (leadzero)
1461             if (c == 0) continue ;
1462             else leadzero = 0 ; /* henceforth we print even zeroes */
1463           nib = c >> 4 ;        /* high nibble bits */
1464           *outbuff++ = hexlate[nib] ;
1465           nib = c & 0x0f ;      /* low nibble bits */
1466           *outbuff++ = hexlate[nib] ;
1467         }
1468       return outbuff ;
1469     }
1470 } /* longlong_hexchars */
1471
1472
1473
1474 /* I am only going to call this when writing virtual byte streams.
1475    Which possably entails endian conversions
1476    */
1477 static int monitor_write_memory_longlongs(memaddr,myaddr,len)
1478      CORE_ADDR memaddr ;
1479      char * myaddr ;
1480      int len ;
1481 {
1482   static char hexstage[20] ; /* At least 16 digits required, plus null */
1483   char * endstring ;
1484   long long * llptr ;
1485   long long value ;
1486   int written = 0 ;
1487   llptr = (unsigned long long *) myaddr ;
1488   if (len == 0 ) return 0 ;
1489   monitor_printf(current_monitor->setmem.cmdll,memaddr) ;
1490   monitor_expect_prompt(NULL,0) ;
1491   while (len >= 8 )
1492     {
1493       value = *llptr ;
1494       endstring = longlong_hexchars(*llptr,hexstage) ;
1495       *endstring = '\0' ; /* NUll terminate for printf */
1496       monitor_printf("%s\r",hexstage) ;
1497       llptr++ ;
1498       memaddr += 8 ;
1499       written += 8 ;
1500       /* If we wanted to, here we could validate the address */
1501       monitor_expect_prompt(NULL,0) ;
1502       len -= 8 ;
1503     }
1504   /* Now exit the sub mode */
1505   monitor_printf (current_monitor->getreg.term_cmd);
1506   monitor_expect_prompt(NULL,0) ;
1507   return written ;
1508 } /* */
1509
1510
1511
1512 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1513 /* This is for the large blocks of memory which may occur in downloading.
1514    And for monitors which use interactive entry,
1515    And for monitors which do not have other downloading methods.
1516    Without this, we will end up calling monitor_write_memory many times
1517    and do the entry and exit of the sub mode many times
1518    This currently assumes...
1519      MO_SETMEM_INTERACTIVE
1520      ! MO_NO_ECHO_ON_SETMEM
1521      To use this, the you have to patch the monitor_cmds block with
1522      this function. Otherwise, its not tuned up for use by all
1523      monitor variations.
1524    */
1525
1526 static int monitor_write_memory_block(memaddr,myaddr,len)
1527      CORE_ADDR memaddr ;
1528      char * myaddr ;
1529      int len ;
1530 {
1531   int written ;
1532   written = 0 ;
1533   /* FIXME: This would be a good place to put the zero test */
1534 #if 1
1535   if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1536        {
1537          return monitor_write_memory_longlongs(memaddr,myaddr,len) ;
1538        }
1539 #endif
1540 #if 0
1541   if (len > 4)
1542     {
1543       int sublen ;
1544       written = monitor_write_even_block(memaddr,myaddr,len) ;
1545       /* Adjust calling parameters by written amount */
1546       memaddr += written ;
1547       myaddr += written ;
1548       len -= written ;
1549     }
1550 #endif
1551   written = monitor_write_memory_bytes(memaddr,myaddr,len) ;
1552   return written ;
1553 }
1554
1555 /* This is an alternate form of monitor_read_memory which is used for monitors
1556    which can only read a single byte/word/etc. at a time.  */
1557
1558 static int
1559 monitor_read_memory_single (memaddr, myaddr, len)
1560      CORE_ADDR memaddr;
1561      char *myaddr;
1562      int len;
1563 {
1564   unsigned int val;
1565   char membuf[sizeof(int) * 2 + 1];
1566   char *p;
1567   char *cmd;
1568   int i;
1569
1570   RDEBUG(("MON read single\n")) ;
1571 #if 0
1572   /* Can't actually use long longs (nice idea, though).  In fact, the
1573      call to strtoul below will fail if it tries to convert a value
1574      that's too big to fit in a long.  */
1575   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1576     {
1577       len = 8;
1578       cmd = current_monitor->getmem.cmdll;
1579     }
1580   else
1581 #endif
1582   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1583     {
1584       len = 4;
1585       cmd = current_monitor->getmem.cmdl;
1586     }
1587   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1588     {
1589       len = 2;
1590       cmd = current_monitor->getmem.cmdw;
1591     }
1592   else
1593     {
1594       len = 1;
1595       cmd = current_monitor->getmem.cmdb;
1596     }
1597
1598   /* Send the examine command.  */
1599
1600   monitor_printf (cmd, memaddr);
1601
1602   /* If RESP_DELIM is specified, we search for that as a leading
1603      delimiter for the memory value.  Otherwise, we just start
1604      searching from the start of the buf.  */
1605
1606   if (current_monitor->getmem.resp_delim)
1607     { RDEBUG(("EXP getmem.resp_delim\n")) ;
1608       monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1609     }
1610
1611   /* Now, read the appropriate number of hex digits for this loc,
1612      skipping spaces.  */
1613
1614   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1615   if (current_monitor->flags & MO_HEX_PREFIX)
1616     {
1617       int c;
1618
1619       c = readchar (timeout);
1620       while (c == ' ')
1621         c = readchar (timeout);
1622       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1623         ;
1624       else
1625         error ("monitor_read_memory_single (0x%x):  bad response from monitor: %.*s%c.",
1626                memaddr, i, membuf, c);
1627     }
1628   for (i = 0; i < len * 2; i++)
1629     {
1630       int c;
1631
1632       while (1)
1633         {
1634           c = readchar (timeout);
1635           if (isxdigit (c))
1636             break;
1637           if (c == ' ')
1638             continue;
1639
1640           error ("monitor_read_memory_single (0x%x):  bad response from monitor: %.*s%c.",
1641                  memaddr, i, membuf, c);
1642         }
1643
1644       membuf[i] = c;
1645     }
1646
1647   membuf[i] = '\000';           /* terminate the number */
1648
1649 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
1650    present), we will send TERM_CMD if that is present.  In any case, we collect
1651    all of the output into buf, and then wait for the normal prompt.  */
1652
1653   if (current_monitor->getmem.term)
1654     {
1655       monitor_expect (current_monitor->getmem.term, NULL, 0); /* get response */
1656
1657       if (current_monitor->getmem.term_cmd)
1658         {
1659           monitor_printf (current_monitor->getmem.term_cmd);
1660           monitor_expect_prompt (NULL, 0);
1661         }
1662     }
1663   else
1664     monitor_expect_prompt (NULL, 0); /* get response */
1665
1666   p = membuf;
1667   val = strtoul (membuf, &p, 16);
1668
1669   if (val == 0 && membuf == p)
1670     error ("monitor_read_memory_single (0x%x):  bad value from monitor: %s.",
1671            memaddr, membuf);
1672
1673   /* supply register stores in target byte order, so swap here */
1674
1675   store_unsigned_integer (myaddr, len, val);
1676
1677   return len;
1678 }
1679
1680 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1681    memory at MEMADDR.  Returns length moved.  Currently, we do no more
1682    than 16 bytes at a time.  */
1683
1684 static int
1685 monitor_read_memory (memaddr, myaddr, len)
1686      CORE_ADDR memaddr;
1687      char *myaddr;
1688      int len;
1689 {
1690   unsigned int val;
1691   char buf[512];
1692   char *p, *p1;
1693   int resp_len;
1694   int i;
1695   CORE_ADDR dumpaddr;
1696
1697   if (remote_debug) printf("MON read block ta(%08x) ha(%08x) %d\n",
1698           (unsigned long) memaddr , (unsigned long)myaddr, len);
1699
1700   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1701     memaddr = ADDR_BITS_REMOVE (memaddr);
1702
1703   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1704     return monitor_read_memory_single (memaddr, myaddr, len);
1705
1706   len = min (len, 16);
1707
1708   /* Some dumpers align the first data with the preceeding 16
1709      byte boundary. Some print blanks and start at the
1710      requested boundary. EXACT_DUMPADDR
1711      */
1712
1713   dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1714     ? memaddr : memaddr & ~ 0x0f ;
1715
1716   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
1717   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1718     len = ((memaddr + len) & ~0xf) - memaddr;
1719
1720   /* send the memory examine command */
1721
1722   if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1723     monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len - 1);
1724   else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1725     monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1726   else
1727     monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1728
1729   /* If TERM is present, we wait for that to show up.  Also, (if TERM
1730      is present), we will send TERM_CMD if that is present.  In any
1731      case, we collect all of the output into buf, and then wait for
1732      the normal prompt.  */
1733
1734   if (current_monitor->getmem.term)
1735     {
1736       resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf); /* get response */
1737
1738       if (resp_len <= 0)
1739         error ("monitor_read_memory (0x%x):  excessive response from monitor: %.*s.",
1740                memaddr, resp_len, buf);
1741
1742       if (current_monitor->getmem.term_cmd)
1743         {
1744           SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
1745                         strlen (current_monitor->getmem.term_cmd));
1746           monitor_expect_prompt (NULL, 0);
1747         }
1748     }
1749   else
1750     resp_len = monitor_expect_prompt (buf, sizeof buf); /* get response */
1751
1752   p = buf;
1753
1754   /* If RESP_DELIM is specified, we search for that as a leading
1755      delimiter for the values.  Otherwise, we just start searching
1756      from the start of the buf.  */
1757
1758   if (current_monitor->getmem.resp_delim)
1759     {
1760       int retval, tmp;
1761       struct re_registers resp_strings;
1762       RDEBUG(("MON getmem.resp_delim %s\n",current_monitor->getmem.resp_delim)) ;
1763
1764       memset (&resp_strings, 0, sizeof (struct re_registers));
1765       tmp = strlen (p);
1766       retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1767                           &resp_strings);
1768
1769       if (retval < 0)
1770         error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
1771                memaddr, resp_len, buf);
1772
1773       p += resp_strings.end[0];
1774 #if 0
1775       p = strstr (p, current_monitor->getmem.resp_delim);
1776       if (!p)
1777         error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
1778                memaddr, resp_len, buf);
1779       p += strlen (current_monitor->getmem.resp_delim);
1780 #endif
1781     }
1782   if (remote_debug) printf("MON scanning  %d ,%08x '%s'\n",len,p,p) ;
1783   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1784     {
1785       char c ;
1786       int fetched = 0 ;
1787       i = len;
1788       c = *p ;
1789
1790
1791       while (!(c  == '\000' || c == '\n' || c == '\r') && i > 0)
1792         { if (isxdigit (c))
1793             { if ((dumpaddr >= memaddr) && (i > 0))
1794                 { val = fromhex (c) * 16 + fromhex (*(p+1));
1795                   *myaddr++ = val;
1796                   if (remote_debug) printf("[%02x]",val) ;
1797                   --i;
1798                   fetched++ ;
1799                 }
1800               ++dumpaddr;
1801               ++p;
1802             }
1803           ++p; /* skip a blank or other non hex char */
1804           c = *p ;
1805         }
1806       if (fetched == 0) error("Failed to read via monitor") ;
1807       if (remote_debug) printf("\n") ;
1808       return fetched ; /* Return the number of bytes actually read */
1809     }
1810   RDEBUG(("MON scanning bytes\n")) ;
1811
1812   for (i = len; i > 0; i--)
1813     {
1814       /* Skip non-hex chars, but bomb on end of string and newlines */
1815
1816       while (1)
1817         {
1818           if (isxdigit (*p))
1819             break;
1820
1821           if (*p == '\000' || *p == '\n' || *p == '\r')
1822             error ("monitor_read_memory (0x%x):  badly terminated response from monitor: %.*s", memaddr, resp_len, buf);
1823           p++;
1824         }
1825
1826       val = strtoul (p, &p1, 16);
1827
1828       if (val == 0 && p == p1)
1829         error ("monitor_read_memory (0x%x):  bad value from monitor: %.*s.", memaddr,
1830                resp_len, buf);
1831
1832       *myaddr++ = val;
1833
1834       if (i == 1)
1835         break;
1836
1837       p = p1;
1838     }
1839
1840   return len;
1841 }
1842
1843 static int
1844 monitor_xfer_memory (memaddr, myaddr, len, write, target)
1845      CORE_ADDR memaddr;
1846      char *myaddr;
1847      int len;
1848      int write;
1849      struct target_ops *target;         /* ignored */
1850 {
1851   return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
1852 }
1853
1854 static void
1855 monitor_kill ()
1856 {
1857   return;               /* ignore attempts to kill target system */
1858 }
1859
1860 /* All we actually do is set the PC to the start address of exec_bfd, and start
1861    the program at that point.  */
1862
1863 static void
1864 monitor_create_inferior (exec_file, args, env)
1865      char *exec_file;
1866      char *args;
1867      char **env;
1868 {
1869   if (args && (*args != '\000'))
1870     error ("Args are not supported by the monitor.");
1871
1872   first_time = 1;
1873   clear_proceed_status ();
1874   proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
1875 }
1876
1877 /* Clean up when a program exits.
1878    The program actually lives on in the remote processor's RAM, and may be
1879    run again without a download.  Don't leave it full of breakpoint
1880    instructions.  */
1881
1882 static void
1883 monitor_mourn_inferior ()
1884 {
1885   unpush_target (targ_ops);
1886   generic_mourn_inferior ();    /* Do all the proper things now */
1887 }
1888
1889 #define NUM_MONITOR_BREAKPOINTS 8
1890
1891 static CORE_ADDR breakaddr[NUM_MONITOR_BREAKPOINTS] = {0};
1892
1893 /* Tell the monitor to add a breakpoint.  */
1894
1895 static int
1896 monitor_insert_breakpoint (addr, shadow)
1897      CORE_ADDR addr;
1898      char *shadow;
1899 {
1900   int i;
1901   unsigned char *bp;
1902   int bplen;
1903
1904   RDEBUG(("MON inst bkpt %08x\n",addr))
1905   if (current_monitor->set_break == NULL)
1906     error ("No set_break defined for this monitor");
1907
1908   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1909     addr = ADDR_BITS_REMOVE (addr);
1910
1911   /* Determine appropriate breakpoint size for this address.  */
1912   bp = memory_breakpoint_from_pc (&addr, &bplen);
1913
1914   for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
1915     {
1916       if (breakaddr[i] == 0)
1917         {
1918           breakaddr[i] = addr;
1919           monitor_read_memory (addr, shadow, bplen);
1920           monitor_printf (current_monitor->set_break, addr);
1921           monitor_expect_prompt (NULL, 0);
1922           return 0;
1923         }
1924     }
1925
1926   error ("Too many breakpoints (> %d) for monitor.", NUM_MONITOR_BREAKPOINTS);
1927 }
1928
1929 /* Tell the monitor to remove a breakpoint.  */
1930
1931 static int
1932 monitor_remove_breakpoint (addr, shadow)
1933      CORE_ADDR addr;
1934      char *shadow;
1935 {
1936   int i;
1937
1938   RDEBUG(("MON rmbkpt %08x\n",addr))
1939   if (current_monitor->clr_break == NULL)
1940     error ("No clr_break defined for this monitor");
1941
1942   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1943     addr = ADDR_BITS_REMOVE (addr);
1944
1945   for (i = 0; i < NUM_MONITOR_BREAKPOINTS; i++)
1946     {
1947       if (breakaddr[i] == addr)
1948         {
1949           breakaddr[i] = 0;
1950           /* some monitors remove breakpoints based on the address */
1951           if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
1952             monitor_printf (current_monitor->clr_break, addr);
1953           else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
1954             monitor_printf (current_monitor->clr_break, i + 1);
1955           else
1956             monitor_printf (current_monitor->clr_break, i);
1957           monitor_expect_prompt (NULL, 0);
1958           return 0;
1959         }
1960     }
1961   fprintf_unfiltered (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
1962   return 1;
1963 }
1964
1965 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
1966    an S-record.  Return non-zero if the ACK is received properly.  */
1967
1968 static int
1969 monitor_wait_srec_ack ()
1970 {
1971   int i, ch;
1972
1973   if (current_monitor->flags & MO_SREC_ACK_PLUS)
1974     {
1975       return (readchar (timeout) == '+');
1976     }
1977   else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
1978     {
1979       /* Eat two backspaces, a "rotating" char (|/-\), and a space.  */
1980       if ((ch = readchar (1)) < 0)
1981         return 0;
1982       if ((ch = readchar (1)) < 0)
1983         return 0;
1984       if ((ch = readchar (1)) < 0)
1985         return 0;
1986       if ((ch = readchar (1)) < 0)
1987         return 0;
1988     }
1989   return 1;
1990 }
1991
1992 /* monitor_load -- download a file. */
1993
1994 static void
1995 monitor_load (file, from_tty)
1996     char *file;
1997     int  from_tty;
1998 {
1999   dcache_flush (remote_dcache);
2000   RDEBUG(("MON load\n"))
2001
2002   if (current_monitor->load_routine)
2003     current_monitor->load_routine (monitor_desc, file, hashmark);
2004   else
2005     {                           /* The default is ascii S-records */
2006       int n;
2007       unsigned long load_offset;
2008       char buf[128];
2009
2010       /* enable user to specify address for downloading as 2nd arg to load */
2011       n = sscanf (file, "%s 0x%lx", buf, &load_offset);
2012       if (n > 1)
2013         file = buf;
2014       else
2015         load_offset = 0;
2016
2017       monitor_printf (current_monitor->load);
2018       if (current_monitor->loadresp)
2019         monitor_expect (current_monitor->loadresp, NULL, 0);
2020
2021       load_srec (monitor_desc, file, (bfd_vma) load_offset,
2022                  32, SREC_ALL, hashmark,
2023                  current_monitor->flags & MO_SREC_ACK ?
2024                    monitor_wait_srec_ack : NULL);
2025
2026       monitor_expect_prompt (NULL, 0);
2027     }
2028
2029 /* Finally, make the PC point at the start address */
2030
2031   if (exec_bfd)
2032     write_pc (bfd_get_start_address (exec_bfd));
2033
2034   inferior_pid = 0;             /* No process now */
2035
2036 /* This is necessary because many things were based on the PC at the time that
2037    we attached to the monitor, which is no longer valid now that we have loaded
2038    new code (and just changed the PC).  Another way to do this might be to call
2039    normal_stop, except that the stack may not be valid, and things would get
2040    horribly confused... */
2041
2042   clear_symtab_users ();
2043 }
2044
2045 static void
2046 monitor_stop ()
2047 {
2048   RDEBUG(("MON stop\n")) ;
2049   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2050     SERIAL_SEND_BREAK (monitor_desc);
2051   if (current_monitor->stop)
2052     monitor_printf_noecho (current_monitor->stop);
2053 }
2054
2055 /* Put a command string, in args, out to MONITOR.  Output from MONITOR
2056    is placed on the users terminal until the prompt is seen. FIXME: We
2057    read the characters ourseleves here cause of a nasty echo.  */
2058
2059 static void
2060 monitor_command (args, from_tty)
2061      char *args;
2062      int from_tty;
2063 {
2064   char *p;
2065   int resp_len;
2066   char buf[1000];
2067
2068   if (monitor_desc == NULL)
2069     error ("monitor target not open.");
2070
2071   p = current_monitor->prompt;
2072
2073   /* Send the command.  Note that if no args were supplied, then we're
2074      just sending the monitor a newline, which is sometimes useful.  */
2075
2076   monitor_printf ("%s\r", (args ? args : ""));
2077
2078   resp_len = monitor_expect_prompt (buf, sizeof buf);
2079
2080   fputs_unfiltered (buf, gdb_stdout); /* Output the response */
2081 }
2082
2083 /* Convert hex digit A to a number.  */
2084
2085 #if 0
2086 static int
2087 from_hex (a)
2088      int a;
2089 {
2090   if (a >= '0' && a <= '9')
2091     return a - '0';
2092   if (a >= 'a' && a <= 'f')
2093     return a - 'a' + 10;
2094   if (a >= 'A' && a <= 'F')
2095     return a - 'A' + 10;
2096
2097   error ("Reply contains invalid hex digit 0x%x", a);
2098 }
2099 #endif
2100
2101 char *
2102 monitor_get_dev_name ()
2103 {
2104   return dev_name;
2105 }
2106
2107 static struct target_ops monitor_ops ;
2108
2109 static void init_base_monitor_ops(void)
2110 {
2111   monitor_ops.to_shortname =   NULL;
2112   monitor_ops.to_longname =   NULL;
2113   monitor_ops.to_doc =   NULL;
2114   monitor_ops.to_open =   NULL;
2115   monitor_ops.to_close =   monitor_close;
2116   monitor_ops.to_attach =   NULL;
2117   monitor_ops.to_detach =   monitor_detach;
2118   monitor_ops.to_resume =   monitor_resume;
2119   monitor_ops.to_wait  =   monitor_wait;
2120   monitor_ops.to_fetch_registers  =   monitor_fetch_registers;
2121   monitor_ops.to_store_registers  =   monitor_store_registers;
2122   monitor_ops.to_prepare_to_store =   monitor_prepare_to_store;
2123   monitor_ops.to_xfer_memory  =   monitor_xfer_memory;
2124   monitor_ops.to_files_info  =   monitor_files_info;
2125   monitor_ops.to_insert_breakpoint =   monitor_insert_breakpoint;
2126   monitor_ops.to_remove_breakpoint =   monitor_remove_breakpoint;
2127   monitor_ops.to_terminal_init  =   0;
2128   monitor_ops.to_terminal_inferior =   0;
2129   monitor_ops.to_terminal_ours_for_output =   0;
2130   monitor_ops.to_terminal_ours  =   0;
2131   monitor_ops.to_terminal_info  =   0;
2132   monitor_ops.to_kill  =   monitor_kill;
2133   monitor_ops.to_load  =   monitor_load;
2134   monitor_ops.to_lookup_symbol =   0;
2135   monitor_ops.to_create_inferior =   monitor_create_inferior;
2136   monitor_ops.to_mourn_inferior =   monitor_mourn_inferior;
2137   monitor_ops.to_can_run  =   0;
2138   monitor_ops.to_notice_signals =   0;
2139   monitor_ops.to_thread_alive  =   0;
2140   monitor_ops.to_stop  =   monitor_stop;
2141   monitor_ops.to_stratum =   process_stratum;
2142   monitor_ops.DONT_USE =   0;
2143   monitor_ops.to_has_all_memory =   1;
2144   monitor_ops.to_has_memory =   1;
2145   monitor_ops.to_has_stack =   1;
2146   monitor_ops.to_has_registers =   1;
2147   monitor_ops.to_has_execution =   1;
2148   monitor_ops.to_sections =   0;
2149   monitor_ops.to_sections_end =   0;
2150   monitor_ops.to_magic =   OPS_MAGIC ;
2151 } /* init_monitor_ops */
2152
2153 /* Init the target_ops structure pointed at by OPS */
2154
2155 void
2156 init_monitor_ops (ops)
2157      struct target_ops *ops;
2158 {
2159   memcpy (ops, &monitor_ops, sizeof monitor_ops);
2160 }
2161
2162 /* Define additional commands that are usually only used by monitors.  */
2163
2164 void
2165 _initialize_remote_monitors ()
2166 {
2167   init_base_monitor_ops() ;
2168   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
2169                                   (char *)&hashmark,
2170                                   "Set display of activity while downloading a file.\n\
2171 When enabled, a hashmark \'#\' is displayed.",
2172                                   &setlist),
2173                      &showlist);
2174
2175   add_com ("monitor", class_obscure, monitor_command,
2176            "Send a command to the debug monitor.");
2177 }