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