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