gdb/monitor.c

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