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