gdb/monitor.c

   1 /* Remote debugging interface for boot monitors, for GDB.
   2    Copyright 1990, 1991, 1992, 1993, 1995, 1996, 1997, 1999
   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,
  22    Boston, MA 02111-1307, USA.  */
  23
  24 /* This file was derived from various remote-* modules. It is a collection
  25    of generic support functions so GDB can talk directly to a ROM based
  26    monitor. This saves use from having to hack an exception based handler
  27    into existance, and makes for quick porting.
  28
  29    This module talks to a debug monitor called 'MONITOR', which
  30    We communicate with MONITOR via either a direct serial line, or a TCP
  31    (or possibly TELNET) stream to a terminal multiplexor,
  32    which in turn talks to the target board.  */
  33
  34 /* FIXME 32x64: This code assumes that registers and addresses are at
  35    most 32 bits long.  If they can be larger, you will need to declare
  36    values as LONGEST and use %llx or some such to print values when
  37    building commands to send to the monitor.  Since we don't know of
  38    any actual 64-bit targets with ROM monitors that use this code,
  39    it's not an issue right now.  -sts 4/18/96  */
  40
  41 #include "defs.h"
  42 #include "gdbcore.h"
  43 #include "target.h"
  44 #include "wait.h"
  45 #ifdef ANSI_PROTOTYPES
  46 #include <stdarg.h>
  47 #else
  48 #include <varargs.h>
  49 #endif
  50 #include <signal.h>
  51 #include <ctype.h>
  52 #include "gdb_string.h"
  53 #include <sys/types.h>
  54 #include "command.h"
  55 #include "serial.h"
  56 #include "monitor.h"
  57 #include "gdbcmd.h"
  58 #include "inferior.h"
  59 #include "gnu-regex.h"
  60 #include "dcache.h"
  61 #include "srec.h"
  62
  63 static char *dev_name;
  64 static struct target_ops *targ_ops;
  65
  66 static void monitor_vsprintf PARAMS ((char *sndbuf, char *pattern, va_list args));
  67
  68 static int readchar PARAMS ((int timeout));
  69
  70 static void monitor_command PARAMS ((char *args, int fromtty));
  71
  72 static void monitor_fetch_register PARAMS ((int regno));
  73 static void monitor_store_register PARAMS ((int regno));
  74
  75 static int monitor_printable_string PARAMS ((char *newstr, char *oldstr));
  76 static void monitor_error PARAMS ((char *format, CORE_ADDR memaddr, int len, char *string, int final_char));
  77 static void monitor_detach PARAMS ((char *args, int from_tty));
  78 static void monitor_resume PARAMS ((int pid, int step, enum target_signal sig));
  79 static void monitor_interrupt PARAMS ((int signo));
  80 static void monitor_interrupt_twice PARAMS ((int signo));
  81 static void monitor_interrupt_query PARAMS ((void));
  82 static void monitor_wait_cleanup PARAMS ((void *old_timeout));
  83
  84 static int monitor_wait PARAMS ((int pid, struct target_waitstatus * status));
  85 static void monitor_fetch_registers PARAMS ((int regno));
  86 static void monitor_store_registers PARAMS ((int regno));
  87 static void monitor_prepare_to_store PARAMS ((void));
  88 static int monitor_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, int write, struct target_ops * target));
  89 static void monitor_files_info PARAMS ((struct target_ops * ops));
  90 static int monitor_insert_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
  91 static int monitor_remove_breakpoint PARAMS ((CORE_ADDR addr, char *shadow));
  92 static void monitor_kill PARAMS ((void));
  93 static void monitor_load PARAMS ((char *file, int from_tty));
  94 static void monitor_mourn_inferior PARAMS ((void));
  95 static void monitor_stop PARAMS ((void));
  96
  97 static int monitor_read_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
  98 static int monitor_write_memory PARAMS ((CORE_ADDR addr, char *myaddr, int len));
  99 static int monitor_write_memory_bytes PARAMS ((CORE_ADDR addr,
 100                                                char *myaddr, int len));
 101 static int monitor_write_memory_block PARAMS ((
 102                                                 CORE_ADDR memaddr,
 103                                                 char *myaddr,
 104                                                 int len));
 105 static int monitor_expect_regexp PARAMS ((struct re_pattern_buffer * pat,
 106                                           char *buf, int buflen));
 107 static void monitor_dump_regs PARAMS ((void));
 108 #if 0
 109 static int from_hex PARAMS ((int a));
 110 static unsigned long get_hex_word PARAMS ((void));
 111 #endif
 112 static void parse_register_dump PARAMS ((char *, int));
 113
 114 static struct monitor_ops *current_monitor;
 115
 116 static int hashmark;            /* flag set by "set hash" */
 117
 118 static int timeout = 30;
 119
 120 static int in_monitor_wait = 0; /* Non-zero means we are in monitor_wait() */
 121
 122 static void (*ofunc) ();        /* Old SIGINT signal handler */
 123
 124 static CORE_ADDR *breakaddr;
 125
 126 /* Extra remote debugging for developing a new rom monitor variation */
 127 #if ! defined(EXTRA_RDEBUG)
 128 #define EXTRA_RDEBUG 0
 129 #endif
 130 #define RDEBUG(stuff) { if (EXTRA_RDEBUG && remote_debug) printf stuff ; }
 131
 132 /* Descriptor for I/O to remote machine.  Initialize it to NULL so
 133    that monitor_open knows that we don't have a file open when the
 134    program starts.  */
 135
 136 static serial_t monitor_desc = NULL;
 137
 138 /* Pointer to regexp pattern matching data */
 139
 140 static struct re_pattern_buffer register_pattern;
 141 static char register_fastmap[256];
 142
 143 static struct re_pattern_buffer getmem_resp_delim_pattern;
 144 static char getmem_resp_delim_fastmap[256];
 145
 146 static int dump_reg_flag;       /* Non-zero means do a dump_registers cmd when
 147                                    monitor_wait wakes up.  */
 148
 149 static DCACHE *remote_dcache;
 150 static int first_time = 0;      /* is this the first time we're executing after
 151                                    gaving created the child proccess? */
 152
 153 /* Convert a string into a printable representation, Return # byte in the
 154    new string.  */
 155
 156 static int
 157 monitor_printable_string (newstr, oldstr)
 158      char *newstr;
 159      char *oldstr;
 160 {
 161   char *save = newstr;
 162   int ch;
 163
 164   while ((ch = *oldstr++) != '\0')
 165     {
 166       switch (ch)
 167         {
 168         default:
 169           if (isprint (ch))
 170             *newstr++ = ch;
 171
 172           else
 173             {
 174               sprintf (newstr, "\\x%02x", ch & 0xff);
 175               newstr += 4;
 176             }
 177           break;
 178
 179         case '\\':
 180           *newstr++ = '\\';
 181           *newstr++ = '\\';
 182           break;
 183         case '\b':
 184           *newstr++ = '\\';
 185           *newstr++ = 'b';
 186           break;
 187         case '\f':
 188           *newstr++ = '\\';
 189           *newstr++ = 't';
 190           break;
 191         case '\n':
 192           *newstr++ = '\\';
 193           *newstr++ = 'n';
 194           break;
 195         case '\r':
 196           *newstr++ = '\\';
 197           *newstr++ = 'r';
 198           break;
 199         case '\t':
 200           *newstr++ = '\\';
 201           *newstr++ = 't';
 202           break;
 203         case '\v':
 204           *newstr++ = '\\';
 205           *newstr++ = 'v';
 206           break;
 207         }
 208     }
 209
 210   *newstr++ = '\0';
 211   return newstr - save;
 212 }
 213
 214 /* Print monitor errors with a string, converting the string to printable
 215    representation.  */
 216
 217 static void
 218 monitor_error (format, memaddr, len, string, final_char)
 219      char *format;
 220      CORE_ADDR memaddr;
 221      int len;
 222      char *string;
 223      int final_char;
 224 {
 225   int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
 226   char *safe_string = alloca ((real_len * 4) + 1);
 227   char *p, *q;
 228   int ch;
 229   int safe_len = monitor_printable_string (safe_string, string);
 230
 231   if (final_char)
 232     error (format, (int) memaddr, p - safe_string, safe_string, final_char);
 233   else
 234     error (format, (int) memaddr, p - safe_string, safe_string);
 235 }
 236
 237 /* Convert hex digit A to a number.  */
 238
 239 static int
 240 fromhex (a)
 241      int a;
 242 {
 243   if (a >= '0' && a <= '9')
 244     return a - '0';
 245   else if (a >= 'a' && a <= 'f')
 246     return a - 'a' + 10;
 247   else if (a >= 'A' && a <= 'F')
 248     return a - 'A' + 10;
 249   else
 250     error ("Invalid hex digit %d", a);
 251 }
 252
 253 /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses
 254
 255    This function exists to get around the problem that many host platforms
 256    don't have a printf that can print 64-bit addresses.  The %A format
 257    specification is recognized as a special case, and causes the argument
 258    to be printed as a 64-bit hexadecimal address.
 259
 260    Only format specifiers of the form "[0-9]*[a-z]" are recognized.
 261    If it is a '%s' format, the argument is a string; otherwise the
 262    argument is assumed to be a long integer.
 263
 264    %% is also turned into a single %.
 265  */
 266
 267 static void
 268 monitor_vsprintf (sndbuf, pattern, args)
 269      char *sndbuf;
 270      char *pattern;
 271      va_list args;
 272 {
 273   char format[10];
 274   char fmt;
 275   char *p;
 276   int i;
 277   long arg_int;
 278   CORE_ADDR arg_addr;
 279   char *arg_string;
 280
 281   for (p = pattern; *p; p++)
 282     {
 283       if (*p == '%')
 284         {
 285           /* Copy the format specifier to a separate buffer.  */
 286           format[0] = *p++;
 287           for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
 288                i++, p++)
 289             format[i] = *p;
 290           format[i] = fmt = *p;
 291           format[i + 1] = '\0';
 292
 293           /* Fetch the next argument and print it.  */
 294           switch (fmt)
 295             {
 296             case '%':
 297               strcpy (sndbuf, "%");
 298               break;
 299             case 'A':
 300               arg_addr = va_arg (args, CORE_ADDR);
 301               strcpy (sndbuf, paddr_nz (arg_addr));
 302               break;
 303             case 's':
 304               arg_string = va_arg (args, char *);
 305               sprintf (sndbuf, format, arg_string);
 306               break;
 307             default:
 308               arg_int = va_arg (args, long);
 309               sprintf (sndbuf, format, arg_int);
 310               break;
 311             }
 312           sndbuf += strlen (sndbuf);
 313         }
 314       else
 315         *sndbuf++ = *p;
 316     }
 317   *sndbuf = '\0';
 318 }
 319
 320
 321 /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
 322    Works just like printf.  */
 323
 324 void
 325 #ifdef ANSI_PROTOTYPES
 326 monitor_printf_noecho (char *pattern,...)
 327 #else
 328 monitor_printf_noecho (va_alist)
 329      va_dcl
 330 #endif
 331 {
 332   va_list args;
 333   char sndbuf[2000];
 334   int len;
 335
 336 #if ANSI_PROTOTYPES
 337   va_start (args, pattern);
 338 #else
 339   char *pattern;
 340   va_start (args);
 341   pattern = va_arg (args, char *);
 342 #endif
 343
 344   monitor_vsprintf (sndbuf, pattern, args);
 345
 346   len = strlen (sndbuf);
 347   if (len + 1 > sizeof sndbuf)
 348     abort ();
 349
 350 #if 0
 351   if (remote_debug > 0)
 352     puts_debug ("sent -->", sndbuf, "<--");
 353 #endif
 354   if (EXTRA_RDEBUG
 355       && remote_debug)
 356     {
 357       char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);
 358       monitor_printable_string (safe_string, sndbuf);
 359       printf ("sent[%s]\n", safe_string);
 360     }
 361
 362   monitor_write (sndbuf, len);
 363 }
 364
 365 /* monitor_printf -- Send data to monitor and check the echo.  Works just like
 366    printf.  */
 367
 368 void
 369 #ifdef ANSI_PROTOTYPES
 370 monitor_printf (char *pattern,...)
 371 #else
 372 monitor_printf (va_alist)
 373      va_dcl
 374 #endif
 375 {
 376   va_list args;
 377   char sndbuf[2000];
 378   int len;
 379
 380 #ifdef ANSI_PROTOTYPES
 381   va_start (args, pattern);
 382 #else
 383   char *pattern;
 384   va_start (args);
 385   pattern = va_arg (args, char *);
 386 #endif
 387
 388   monitor_vsprintf (sndbuf, pattern, args);
 389
 390   len = strlen (sndbuf);
 391   if (len + 1 > sizeof sndbuf)
 392     abort ();
 393
 394 #if 0
 395   if (remote_debug > 0)
 396     puts_debug ("sent -->", sndbuf, "<--");
 397 #endif
 398   if (EXTRA_RDEBUG
 399       && remote_debug)
 400     {
 401       char *safe_string = (char *) alloca ((len * 4) + 1);
 402       monitor_printable_string (safe_string, sndbuf);
 403       printf ("sent[%s]\n", safe_string);
 404     }
 405
 406   monitor_write (sndbuf, len);
 407
 408   /* We used to expect that the next immediate output was the characters we
 409      just output, but sometimes some extra junk appeared before the characters
 410      we expected, like an extra prompt, or a portmaster sending telnet negotiations.
 411      So, just start searching for what we sent, and skip anything unknown.  */
 412   RDEBUG (("ExpectEcho\n"))
 413     monitor_expect (sndbuf, (char *) 0, 0);
 414 }
 415
 416
 417 /* Write characters to the remote system.  */
 418
 419 void
 420 monitor_write (buf, buflen)
 421      char *buf;
 422      int buflen;
 423 {
 424   if (SERIAL_WRITE (monitor_desc, buf, buflen))
 425     fprintf_unfiltered (gdb_stderr, "SERIAL_WRITE failed: %s\n",
 426                         safe_strerror (errno));
 427 }
 428
 429
 430 /* Read a binary character from the remote system, doing all the fancy
 431    timeout stuff, but without interpreting the character in any way,
 432    and without printing remote debug information.  */
 433
 434 int
 435 monitor_readchar ()
 436 {
 437   int c;
 438   int looping;
 439
 440   do
 441     {
 442       looping = 0;
 443       c = SERIAL_READCHAR (monitor_desc, timeout);
 444
 445       if (c >= 0)
 446         c &= 0xff;              /* don't lose bit 7 */
 447     }
 448   while (looping);
 449
 450   if (c >= 0)
 451     return c;
 452
 453   if (c == SERIAL_TIMEOUT)
 454     error ("Timeout reading from remote system.");
 455
 456   perror_with_name ("remote-monitor");
 457 }
 458
 459
 460 /* Read a character from the remote system, doing all the fancy
 461    timeout stuff.  */
 462
 463 static int
 464 readchar (timeout)
 465      int timeout;
 466 {
 467   int c;
 468   static enum
 469     {
 470       last_random, last_nl, last_cr, last_crnl
 471     }
 472   state = last_random;
 473   int looping;
 474
 475   do
 476     {
 477       looping = 0;
 478       c = SERIAL_READCHAR (monitor_desc, timeout);
 479
 480       if (c >= 0)
 481         {
 482           c &= 0x7f;
 483 #if 0
 484           /* This seems to interfere with proper function of the
 485              input stream */
 486           if (remote_debug > 0)
 487             {
 488               char buf[2];
 489               buf[0] = c;
 490               buf[1] = '\0';
 491               puts_debug ("read -->", buf, "<--");
 492             }
 493
 494 #endif
 495         }
 496
 497       /* Canonicialize \n\r combinations into one \r */
 498       if ((current_monitor->flags & MO_HANDLE_NL) != 0)
 499         {
 500           if ((c == '\r' && state == last_nl)
 501               || (c == '\n' && state == last_cr))
 502             {
 503               state = last_crnl;
 504               looping = 1;
 505             }
 506           else if (c == '\r')
 507             state = last_cr;
 508           else if (c != '\n')
 509             state = last_random;
 510           else
 511             {
 512               state = last_nl;
 513               c = '\r';
 514             }
 515         }
 516     }
 517   while (looping);
 518
 519   if (c >= 0)
 520     return c;
 521
 522   if (c == SERIAL_TIMEOUT)
 523 #if 0
 524     /* I fail to see how detaching here can be useful */
 525     if (in_monitor_wait)        /* Watchdog went off */
 526       {
 527         target_mourn_inferior ();
 528         error ("GDB serial timeout has expired.  Target detached.\n");
 529       }
 530     else
 531 #endif
 532       error ("Timeout reading from remote system.");
 533
 534   perror_with_name ("remote-monitor");
 535 }
 536
 537 /* Scan input from the remote system, until STRING is found.  If BUF is non-
 538    zero, then collect input until we have collected either STRING or BUFLEN-1
 539    chars.  In either case we terminate BUF with a 0.  If input overflows BUF
 540    because STRING can't be found, return -1, else return number of chars in BUF
 541    (minus the terminating NUL).  Note that in the non-overflow case, STRING
 542    will be at the end of BUF.  */
 543
 544 int
 545 monitor_expect (string, buf, buflen)
 546      char *string;
 547      char *buf;
 548      int buflen;
 549 {
 550   char *p = string;
 551   int obuflen = buflen;
 552   int c;
 553   extern struct target_ops *targ_ops;
 554
 555   if (EXTRA_RDEBUG
 556       && remote_debug)
 557     {
 558       char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
 559       monitor_printable_string (safe_string, string);
 560       printf ("MON Expecting '%s'\n", safe_string);
 561     }
 562
 563   immediate_quit = 1;
 564   while (1)
 565     {
 566       if (buf)
 567         {
 568           if (buflen < 2)
 569             {
 570               *buf = '\000';
 571               immediate_quit = 0;
 572               return -1;
 573             }
 574
 575           c = readchar (timeout);
 576           if (c == '\000')
 577             continue;
 578           *buf++ = c;
 579           buflen--;
 580         }
 581       else
 582         c = readchar (timeout);
 583
 584       /* Don't expect any ^C sent to be echoed */
 585
 586       if (*p == '\003' || c == *p)
 587         {
 588           p++;
 589           if (*p == '\0')
 590             {
 591               immediate_quit = 0;
 592
 593               if (buf)
 594                 {
 595                   *buf++ = '\000';
 596                   return obuflen - buflen;
 597                 }
 598               else
 599                 return 0;
 600             }
 601         }
 602       else if ((c == '\021' || c == '\023') &&
 603                (STREQ (targ_ops->to_shortname, "m32r")
 604                 || STREQ (targ_ops->to_shortname, "mon2000")))
 605         {                       /* m32r monitor emits random DC1/DC3 chars */
 606           continue;
 607         }
 608       else
 609         {
 610           p = string;
 611           if (c == *p)
 612             p++;
 613         }
 614     }
 615 }
 616
 617 /* Search for a regexp.  */
 618
 619 static int
 620 monitor_expect_regexp (pat, buf, buflen)
 621      struct re_pattern_buffer *pat;
 622      char *buf;
 623      int buflen;
 624 {
 625   char *mybuf;
 626   char *p;
 627   RDEBUG (("MON Expecting regexp\n"));
 628   if (buf)
 629     mybuf = buf;
 630   else
 631     {
 632       mybuf = alloca (1024);
 633       buflen = 1024;
 634     }
 635
 636   p = mybuf;
 637   while (1)
 638     {
 639       int retval;
 640
 641       if (p - mybuf >= buflen)
 642         {                       /* Buffer about to overflow */
 643
 644 /* On overflow, we copy the upper half of the buffer to the lower half.  Not
 645    great, but it usually works... */
 646
 647           memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
 648           p = mybuf + buflen / 2;
 649         }
 650
 651       *p++ = readchar (timeout);
 652
 653       retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
 654       if (retval >= 0)
 655         return 1;
 656     }
 657 }
 658
 659 /* Keep discarding input until we see the MONITOR prompt.
 660
 661    The convention for dealing with the prompt is that you
 662    o give your command
 663    o *then* wait for the prompt.
 664
 665    Thus the last thing that a procedure does with the serial line will
 666    be an monitor_expect_prompt().  Exception: monitor_resume does not
 667    wait for the prompt, because the terminal is being handed over to
 668    the inferior.  However, the next thing which happens after that is
 669    a monitor_wait which does wait for the prompt.  Note that this
 670    includes abnormal exit, e.g. error().  This is necessary to prevent
 671    getting into states from which we can't recover.  */
 672
 673 int
 674 monitor_expect_prompt (buf, buflen)
 675      char *buf;
 676      int buflen;
 677 {
 678   RDEBUG (("MON Expecting prompt\n"))
 679     return monitor_expect (current_monitor->prompt, buf, buflen);
 680 }
 681
 682 /* Get N 32-bit words from remote, each preceded by a space, and put
 683    them in registers starting at REGNO.  */
 684
 685 #if 0
 686 static unsigned long
 687 get_hex_word ()
 688 {
 689   unsigned long val;
 690   int i;
 691   int ch;
 692
 693   do
 694     ch = readchar (timeout);
 695   while (isspace (ch));
 696
 697   val = from_hex (ch);
 698
 699   for (i = 7; i >= 1; i--)
 700     {
 701       ch = readchar (timeout);
 702       if (!isxdigit (ch))
 703         break;
 704       val = (val << 4) | from_hex (ch);
 705     }
 706
 707   return val;
 708 }
 709 #endif
 710
 711 static void
 712 compile_pattern (pattern, compiled_pattern, fastmap)
 713      char *pattern;
 714      struct re_pattern_buffer *compiled_pattern;
 715      char *fastmap;
 716 {
 717   int tmp;
 718   const char *val;
 719
 720   compiled_pattern->fastmap = fastmap;
 721
 722   tmp = re_set_syntax (RE_SYNTAX_EMACS);
 723   val = re_compile_pattern (pattern,
 724                             strlen (pattern),
 725                             compiled_pattern);
 726   re_set_syntax (tmp);
 727
 728   if (val)
 729     error ("compile_pattern: Can't compile pattern string `%s': %s!", pattern, val);
 730
 731   if (fastmap)
 732     re_compile_fastmap (compiled_pattern);
 733 }
 734
 735 /* Open a connection to a remote debugger. NAME is the filename used
 736    for communication.  */
 737
 738 void
 739 monitor_open (args, mon_ops, from_tty)
 740      char *args;
 741      struct monitor_ops *mon_ops;
 742      int from_tty;
 743 {
 744   char *name;
 745   char **p;
 746
 747   if (mon_ops->magic != MONITOR_OPS_MAGIC)
 748     error ("Magic number of monitor_ops struct wrong.");
 749
 750   targ_ops = mon_ops->target;
 751   name = targ_ops->to_shortname;
 752
 753   if (!args)
 754     error ("Use `target %s DEVICE-NAME' to use a serial port, or \n\
 755 `target %s HOST-NAME:PORT-NUMBER' to use a network connection.", name, name);
 756
 757   target_preopen (from_tty);
 758
 759   /* Setup pattern for register dump */
 760
 761   if (mon_ops->register_pattern)
 762     compile_pattern (mon_ops->register_pattern, &register_pattern,
 763                      register_fastmap);
 764
 765   if (mon_ops->getmem.resp_delim)
 766     compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
 767                      getmem_resp_delim_fastmap);
 768
 769   unpush_target (targ_ops);
 770
 771   if (dev_name)
 772     free (dev_name);
 773   dev_name = strsave (args);
 774
 775   monitor_desc = SERIAL_OPEN (dev_name);
 776
 777   if (!monitor_desc)
 778     perror_with_name (dev_name);
 779
 780   if (baud_rate != -1)
 781     {
 782       if (SERIAL_SETBAUDRATE (monitor_desc, baud_rate))
 783         {
 784           SERIAL_CLOSE (monitor_desc);
 785           perror_with_name (dev_name);
 786         }
 787     }
 788
 789   SERIAL_RAW (monitor_desc);
 790
 791   SERIAL_FLUSH_INPUT (monitor_desc);
 792
 793   /* some systems only work with 2 stop bits */
 794
 795   SERIAL_SETSTOPBITS (monitor_desc, mon_ops->stopbits);
 796
 797   current_monitor = mon_ops;
 798
 799   /* See if we can wake up the monitor.  First, try sending a stop sequence,
 800      then send the init strings.  Last, remove all breakpoints.  */
 801
 802   if (current_monitor->stop)
 803     {
 804       monitor_stop ();
 805       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
 806         {
 807           RDEBUG (("EXP Open echo\n"));
 808           monitor_expect_prompt (NULL, 0);
 809         }
 810     }
 811
 812   /* wake up the monitor and see if it's alive */
 813   for (p = mon_ops->init; *p != NULL; p++)
 814     {
 815       /* Some of the characters we send may not be echoed,
 816          but we hope to get a prompt at the end of it all. */
 817
 818       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
 819         monitor_printf (*p);
 820       else
 821         monitor_printf_noecho (*p);
 822       monitor_expect_prompt (NULL, 0);
 823     }
 824
 825   SERIAL_FLUSH_INPUT (monitor_desc);
 826
 827   /* Alloc breakpoints */
 828   if (mon_ops->set_break != NULL)
 829     {
 830       if (mon_ops->num_breakpoints == 0)
 831         mon_ops->num_breakpoints = 8;
 832
 833       breakaddr = (CORE_ADDR *) xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
 834       memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
 835     }
 836
 837   /* Remove all breakpoints */
 838
 839   if (mon_ops->clr_all_break)
 840     {
 841       monitor_printf (mon_ops->clr_all_break);
 842       monitor_expect_prompt (NULL, 0);
 843     }
 844
 845   if (from_tty)
 846     printf_unfiltered ("Remote target %s connected to %s\n", name, dev_name);
 847
 848   push_target (targ_ops);
 849
 850   inferior_pid = 42000;         /* Make run command think we are busy... */
 851
 852   /* Give monitor_wait something to read */
 853
 854   monitor_printf (current_monitor->line_term);
 855
 856   if (current_monitor->flags & MO_HAS_BLOCKWRITES)
 857     remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory_block);
 858   else
 859     remote_dcache = dcache_init (monitor_read_memory, monitor_write_memory);
 860   start_remote ();
 861 }
 862
 863 /* Close out all files and local state before this target loses
 864    control.  */
 865
 866 void
 867 monitor_close (quitting)
 868      int quitting;
 869 {
 870   if (monitor_desc)
 871     SERIAL_CLOSE (monitor_desc);
 872
 873   /* Free breakpoint memory */
 874   if (breakaddr != NULL)
 875     {
 876       free (breakaddr);
 877       breakaddr = NULL;
 878     }
 879
 880   monitor_desc = NULL;
 881 }
 882
 883 /* Terminate the open connection to the remote debugger.  Use this
 884    when you want to detach and do something else with your gdb.  */
 885
 886 static void
 887 monitor_detach (args, from_tty)
 888      char *args;
 889      int from_tty;
 890 {
 891   pop_target ();                /* calls monitor_close to do the real work */
 892   if (from_tty)
 893     printf_unfiltered ("Ending remote %s debugging\n", target_shortname);
 894 }
 895
 896 /* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */
 897
 898 char *
 899 monitor_supply_register (regno, valstr)
 900      int regno;
 901      char *valstr;
 902 {
 903   unsigned int val;
 904   unsigned char regbuf[MAX_REGISTER_RAW_SIZE];
 905   char *p;
 906
 907   val = strtoul (valstr, &p, 16);
 908   RDEBUG (("Supplying Register %d %s\n", regno, valstr));
 909
 910   if (val == 0 && valstr == p)
 911     error ("monitor_supply_register (%d):  bad value from monitor: %s.",
 912            regno, valstr);
 913
 914   /* supply register stores in target byte order, so swap here */
 915
 916   store_unsigned_integer (regbuf, REGISTER_RAW_SIZE (regno), val);
 917
 918   supply_register (regno, regbuf);
 919
 920   return p;
 921 }
 922
 923 /* Tell the remote machine to resume.  */
 924
 925 void
 926 flush_monitor_dcache ()
 927 {
 928   dcache_flush (remote_dcache);
 929 }
 930
 931 static void
 932 monitor_resume (pid, step, sig)
 933      int pid, step;
 934      enum target_signal sig;
 935 {
 936   /* Some monitors require a different command when starting a program */
 937   RDEBUG (("MON resume\n"));
 938   if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
 939     {
 940       first_time = 0;
 941       monitor_printf ("run\r");
 942       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
 943         dump_reg_flag = 1;
 944       return;
 945     }
 946   dcache_flush (remote_dcache);
 947   if (step)
 948     monitor_printf (current_monitor->step);
 949   else
 950     {
 951       if (current_monitor->continue_hook)
 952         (*current_monitor->continue_hook) ();
 953       else
 954         monitor_printf (current_monitor->cont);
 955       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
 956         dump_reg_flag = 1;
 957     }
 958 }
 959
 960 /* Parse the output of a register dump command.  A monitor specific
 961    regexp is used to extract individual register descriptions of the
 962    form REG=VAL.  Each description is split up into a name and a value
 963    string which are passed down to monitor specific code.  */
 964
 965 static void
 966 parse_register_dump (buf, len)
 967      char *buf;
 968      int len;
 969 {
 970   RDEBUG (("MON Parsing  register dump\n"))
 971     while (1)
 972     {
 973       int regnamelen, vallen;
 974       char *regname, *val;
 975       /* Element 0 points to start of register name, and element 1
 976          points to the start of the register value.  */
 977       struct re_registers register_strings;
 978
 979       memset (&register_strings, 0, sizeof (struct re_registers));
 980
 981       if (re_search (&register_pattern, buf, len, 0, len,
 982                      &register_strings) == -1)
 983         break;
 984
 985       regnamelen = register_strings.end[1] - register_strings.start[1];
 986       regname = buf + register_strings.start[1];
 987       vallen = register_strings.end[2] - register_strings.start[2];
 988       val = buf + register_strings.start[2];
 989
 990       current_monitor->supply_register (regname, regnamelen, val, vallen);
 991
 992       buf += register_strings.end[0];
 993       len -= register_strings.end[0];
 994     }
 995 }
 996
 997 /* Send ^C to target to halt it.  Target will respond, and send us a
 998    packet.  */
 999
1000 static void
1001 monitor_interrupt (signo)
1002      int signo;
1003 {
1004   /* If this doesn't work, try more severe steps.  */
1005   signal (signo, monitor_interrupt_twice);
1006
1007   if (remote_debug)
1008     printf_unfiltered ("monitor_interrupt called\n");
1009
1010   target_stop ();
1011 }
1012
1013 /* The user typed ^C twice.  */
1014
1015 static void
1016 monitor_interrupt_twice (signo)
1017      int signo;
1018 {
1019   signal (signo, ofunc);
1020
1021   monitor_interrupt_query ();
1022
1023   signal (signo, monitor_interrupt);
1024 }
1025
1026 /* Ask the user what to do when an interrupt is received.  */
1027
1028 static void
1029 monitor_interrupt_query ()
1030 {
1031   target_terminal_ours ();
1032
1033   if (query ("Interrupted while waiting for the program.\n\
1034 Give up (and stop debugging it)? "))
1035     {
1036       target_mourn_inferior ();
1037       return_to_top_level (RETURN_QUIT);
1038     }
1039
1040   target_terminal_inferior ();
1041 }
1042
1043 static void
1044 monitor_wait_cleanup (old_timeout)
1045      void *old_timeout;
1046 {
1047   timeout = *(int *) old_timeout;
1048   signal (SIGINT, ofunc);
1049   in_monitor_wait = 0;
1050 }
1051
1052
1053
1054 void
1055 monitor_wait_filter (char *buf,
1056                      int bufmax,
1057                      int *ext_resp_len,
1058                      struct target_waitstatus *status
1059 )
1060 {
1061   int resp_len;
1062   do
1063     {
1064       resp_len = monitor_expect_prompt (buf, bufmax);
1065       *ext_resp_len = resp_len;
1066
1067       if (resp_len <= 0)
1068         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
1069     }
1070   while (resp_len < 0);
1071
1072   /* Print any output characters that were preceded by ^O.  */
1073   /* FIXME - This would be great as a user settabgle flag */
1074   if (remote_debug ||
1075       current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1076     {
1077       int i;
1078
1079       for (i = 0; i < resp_len - 1; i++)
1080         if (buf[i] == 0x0f)
1081           putchar_unfiltered (buf[++i]);
1082     }
1083 }
1084
1085
1086
1087 /* Wait until the remote machine stops, then return, storing status in
1088    status just as `wait' would.  */
1089
1090 static int
1091 monitor_wait (pid, status)
1092      int pid;
1093      struct target_waitstatus *status;
1094 {
1095   int old_timeout = timeout;
1096   char buf[1024];
1097   int resp_len;
1098   struct cleanup *old_chain;
1099
1100   status->kind = TARGET_WAITKIND_EXITED;
1101   status->value.integer = 0;
1102
1103   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
1104   RDEBUG (("MON wait\n"))
1105
1106 #if 0
1107   /* This is somthing other than a maintenance command */
1108     in_monitor_wait = 1;
1109   timeout = watchdog > 0 ? watchdog : -1;
1110 #else
1111     timeout = -1;               /* Don't time out -- user program is running. */
1112 #endif
1113
1114   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);
1115
1116   if (current_monitor->wait_filter)
1117     (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
1118   else
1119     monitor_wait_filter (buf, sizeof (buf), &resp_len, status);
1120
1121 #if 0                           /* Transferred to monitor wait filter */
1122   do
1123     {
1124       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1125
1126       if (resp_len <= 0)
1127         fprintf_unfiltered (gdb_stderr, "monitor_wait:  excessive response from monitor: %s.", buf);
1128     }
1129   while (resp_len < 0);
1130
1131   /* Print any output characters that were preceded by ^O.  */
1132   /* FIXME - This would be great as a user settabgle flag */
1133   if (remote_debug ||
1134       current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
1135     {
1136       int i;
1137
1138       for (i = 0; i < resp_len - 1; i++)
1139         if (buf[i] == 0x0f)
1140           putchar_unfiltered (buf[++i]);
1141     }
1142 #endif
1143
1144   signal (SIGINT, ofunc);
1145
1146   timeout = old_timeout;
1147 #if 0
1148   if (dump_reg_flag && current_monitor->dump_registers)
1149     {
1150       dump_reg_flag = 0;
1151       monitor_printf (current_monitor->dump_registers);
1152       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1153     }
1154
1155   if (current_monitor->register_pattern)
1156     parse_register_dump (buf, resp_len);
1157 #else
1158   RDEBUG (("Wait fetching registers after stop\n"));
1159   monitor_dump_regs ();
1160 #endif
1161
1162   status->kind = TARGET_WAITKIND_STOPPED;
1163   status->value.sig = TARGET_SIGNAL_TRAP;
1164
1165   discard_cleanups (old_chain);
1166
1167   in_monitor_wait = 0;
1168
1169   return inferior_pid;
1170 }
1171
1172 /* Fetch register REGNO, or all registers if REGNO is -1. Returns
1173    errno value.  */
1174
1175 static void
1176 monitor_fetch_register (regno)
1177      int regno;
1178 {
1179   char *name;
1180   static char zerobuf[MAX_REGISTER_RAW_SIZE] =
1181   {0};
1182   char regbuf[MAX_REGISTER_RAW_SIZE * 2 + 1];
1183   int i;
1184
1185   name = current_monitor->regnames[regno];
1186   RDEBUG (("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)"))
1187
1188     if (!name || (*name == '\0'))
1189     {
1190       RDEBUG (("No register known for %d\n", regno))
1191         supply_register (regno, zerobuf);
1192       return;
1193     }
1194
1195   /* send the register examine command */
1196
1197   monitor_printf (current_monitor->getreg.cmd, name);
1198
1199   /* If RESP_DELIM is specified, we search for that as a leading
1200      delimiter for the register value.  Otherwise, we just start
1201      searching from the start of the buf.  */
1202
1203   if (current_monitor->getreg.resp_delim)
1204     {
1205       RDEBUG (("EXP getreg.resp_delim\n"))
1206         monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1207       /* Handle case of first 32 registers listed in pairs.  */
1208       if (current_monitor->flags & MO_32_REGS_PAIRED
1209           && (regno & 1) != 0 && regno < 32)
1210         {
1211           RDEBUG (("EXP getreg.resp_delim\n"));
1212           monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
1213         }
1214     }
1215
1216   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set */
1217   if (current_monitor->flags & MO_HEX_PREFIX)
1218     {
1219       int c;
1220       c = readchar (timeout);
1221       while (c == ' ')
1222         c = readchar (timeout);
1223       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1224         ;
1225       else
1226         error ("Bad value returned from monitor while fetching register %x.",
1227                regno);
1228     }
1229
1230   /* Read upto the maximum number of hex digits for this register, skipping
1231      spaces, but stop reading if something else is seen.  Some monitors
1232      like to drop leading zeros.  */
1233
1234   for (i = 0; i < REGISTER_RAW_SIZE (regno) * 2; i++)
1235     {
1236       int c;
1237       c = readchar (timeout);
1238       while (c == ' ')
1239         c = readchar (timeout);
1240
1241       if (!isxdigit (c))
1242         break;
1243
1244       regbuf[i] = c;
1245     }
1246
1247   regbuf[i] = '\000';           /* terminate the number */
1248   RDEBUG (("REGVAL '%s'\n", regbuf));
1249
1250   /* If TERM is present, we wait for that to show up.  Also, (if TERM
1251      is present), we will send TERM_CMD if that is present.  In any
1252      case, we collect all of the output into buf, and then wait for
1253      the normal prompt.  */
1254
1255   if (current_monitor->getreg.term)
1256     {
1257       RDEBUG (("EXP getreg.term\n"))
1258         monitor_expect (current_monitor->getreg.term, NULL, 0);         /* get response */
1259     }
1260
1261   if (current_monitor->getreg.term_cmd)
1262     {
1263       RDEBUG (("EMIT getreg.term.cmd\n"))
1264         monitor_printf (current_monitor->getreg.term_cmd);
1265     }
1266   if (!current_monitor->getreg.term ||  /* Already expected or */
1267       current_monitor->getreg.term_cmd)         /* ack expected */
1268     monitor_expect_prompt (NULL, 0);    /* get response */
1269
1270   monitor_supply_register (regno, regbuf);
1271 }
1272
1273 /* Sometimes, it takes several commands to dump the registers */
1274 /* This is a primitive for use by variations of monitor interfaces in
1275    case they need to compose the operation.
1276  */
1277 int
1278 monitor_dump_reg_block (char *block_cmd)
1279 {
1280   char buf[1024];
1281   int resp_len;
1282   monitor_printf (block_cmd);
1283   resp_len = monitor_expect_prompt (buf, sizeof (buf));
1284   parse_register_dump (buf, resp_len);
1285   return 1;
1286 }
1287
1288
1289 /* Read the remote registers into the block regs.  */
1290 /* Call the specific function if it has been provided */
1291
1292 static void
1293 monitor_dump_regs ()
1294 {
1295   char buf[1024];
1296   int resp_len;
1297   if (current_monitor->dumpregs)
1298     (*(current_monitor->dumpregs)) ();  /* call supplied function */
1299   else if (current_monitor->dump_registers)     /* default version */
1300     {
1301       monitor_printf (current_monitor->dump_registers);
1302       resp_len = monitor_expect_prompt (buf, sizeof (buf));
1303       parse_register_dump (buf, resp_len);
1304     }
1305   else
1306     abort ();                   /* Need some way to read registers */
1307 }
1308
1309 static void
1310 monitor_fetch_registers (regno)
1311      int regno;
1312 {
1313   RDEBUG (("MON fetchregs\n"));
1314   if (current_monitor->getreg.cmd)
1315     {
1316       if (regno >= 0)
1317         {
1318           monitor_fetch_register (regno);
1319           return;
1320         }
1321
1322       for (regno = 0; regno < NUM_REGS; regno++)
1323         monitor_fetch_register (regno);
1324     }
1325   else
1326     {
1327       monitor_dump_regs ();
1328     }
1329 }
1330
1331 /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */
1332
1333 static void
1334 monitor_store_register (regno)
1335      int regno;
1336 {
1337   char *name;
1338   unsigned int val;
1339
1340   name = current_monitor->regnames[regno];
1341   if (!name || (*name == '\0'))
1342     {
1343       RDEBUG (("MON Cannot store unknown register\n"))
1344         return;
1345     }
1346
1347   val = read_register (regno);
1348   RDEBUG (("MON storeg %d %08x\n", regno, (unsigned int) val))
1349
1350   /* send the register deposit command */
1351
1352     if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
1353     monitor_printf (current_monitor->setreg.cmd, val, name);
1354   else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1355     monitor_printf (current_monitor->setreg.cmd, name);
1356   else
1357     monitor_printf (current_monitor->setreg.cmd, name, val);
1358
1359   if (current_monitor->setreg.term)
1360     {
1361       RDEBUG (("EXP setreg.term\n"))
1362         monitor_expect (current_monitor->setreg.term, NULL, 0);
1363       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
1364         monitor_printf ("%x\r", val);
1365       monitor_expect_prompt (NULL, 0);
1366     }
1367   else
1368     monitor_expect_prompt (NULL, 0);
1369   if (current_monitor->setreg.term_cmd)         /* Mode exit required */
1370     {
1371       RDEBUG (("EXP setreg_termcmd\n"));
1372       monitor_printf ("%s", current_monitor->setreg.term_cmd);
1373       monitor_expect_prompt (NULL, 0);
1374     }
1375 }                               /* monitor_store_register */
1376
1377 /* Store the remote registers.  */
1378
1379 static void
1380 monitor_store_registers (regno)
1381      int regno;
1382 {
1383   if (regno >= 0)
1384     {
1385       monitor_store_register (regno);
1386       return;
1387     }
1388
1389   for (regno = 0; regno < NUM_REGS; regno++)
1390     monitor_store_register (regno);
1391 }
1392
1393 /* Get ready to modify the registers array.  On machines which store
1394    individual registers, this doesn't need to do anything.  On machines
1395    which store all the registers in one fell swoop, this makes sure
1396    that registers contains all the registers from the program being
1397    debugged.  */
1398
1399 static void
1400 monitor_prepare_to_store ()
1401 {
1402   /* Do nothing, since we can store individual regs */
1403 }
1404
1405 static void
1406 monitor_files_info (ops)
1407      struct target_ops *ops;
1408 {
1409   printf_unfiltered ("\tAttached to %s at %d baud.\n", dev_name, baud_rate);
1410 }
1411
1412 static int
1413 monitor_write_memory (memaddr, myaddr, len)
1414      CORE_ADDR memaddr;
1415      char *myaddr;
1416      int len;
1417 {
1418   unsigned int val, hostval;
1419   char *cmd;
1420   int i;
1421
1422   RDEBUG (("MON write %d %08x\n", len, (unsigned long) memaddr))
1423
1424     if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1425     memaddr = ADDR_BITS_REMOVE (memaddr);
1426
1427   /* Use memory fill command for leading 0 bytes.  */
1428
1429   if (current_monitor->fill)
1430     {
1431       for (i = 0; i < len; i++)
1432         if (myaddr[i] != 0)
1433           break;
1434
1435       if (i > 4)                /* More than 4 zeros is worth doing */
1436         {
1437           RDEBUG (("MON FILL %d\n", i))
1438             if (current_monitor->flags & MO_FILL_USES_ADDR)
1439             monitor_printf (current_monitor->fill, memaddr, (memaddr + i) - 1, 0);
1440           else
1441             monitor_printf (current_monitor->fill, memaddr, i, 0);
1442
1443           monitor_expect_prompt (NULL, 0);
1444
1445           return i;
1446         }
1447     }
1448
1449 #if 0
1450   /* Can't actually use long longs if VAL is an int (nice idea, though).  */
1451   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
1452     {
1453       len = 8;
1454       cmd = current_monitor->setmem.cmdll;
1455     }
1456   else
1457 #endif
1458   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
1459     {
1460       len = 4;
1461       cmd = current_monitor->setmem.cmdl;
1462     }
1463   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
1464     {
1465       len = 2;
1466       cmd = current_monitor->setmem.cmdw;
1467     }
1468   else
1469     {
1470       len = 1;
1471       cmd = current_monitor->setmem.cmdb;
1472     }
1473
1474   val = extract_unsigned_integer (myaddr, len);
1475
1476   if (len == 4)
1477     {
1478       hostval = *(unsigned int *) myaddr;
1479       RDEBUG (("Hostval(%08x) val(%08x)\n", hostval, val));
1480     }
1481
1482
1483   if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
1484     monitor_printf_noecho (cmd, memaddr, val);
1485   else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
1486     {
1487
1488       monitor_printf_noecho (cmd, memaddr);
1489
1490       if (current_monitor->setmem.term)
1491         {
1492           RDEBUG (("EXP setmem.term"));
1493           monitor_expect (current_monitor->setmem.term, NULL, 0);
1494           monitor_printf ("%x\r", val);
1495         }
1496       if (current_monitor->setmem.term_cmd)
1497         {                       /* Emit this to get out of the memory editing state */
1498           monitor_printf ("%s", current_monitor->setmem.term_cmd);
1499           /* Drop through to expecting a prompt */
1500         }
1501     }
1502   else
1503     monitor_printf (cmd, memaddr, val);
1504
1505   monitor_expect_prompt (NULL, 0);
1506
1507   return len;
1508 }
1509
1510
1511 static int
1512 monitor_write_even_block (memaddr, myaddr, len)
1513      CORE_ADDR memaddr;
1514      char *myaddr;
1515      int len;
1516 {
1517   unsigned int val;
1518   int written = 0;;
1519   /* Enter the sub mode */
1520   monitor_printf (current_monitor->setmem.cmdl, memaddr);
1521   monitor_expect_prompt (NULL, 0);
1522
1523   while (len)
1524     {
1525       val = extract_unsigned_integer (myaddr, 4);       /* REALLY */
1526       monitor_printf ("%x\r", val);
1527       myaddr += 4;
1528       memaddr += 4;
1529       written += 4;
1530       RDEBUG ((" @ %08x\n", memaddr))
1531       /* If we wanted to, here we could validate the address */
1532         monitor_expect_prompt (NULL, 0);
1533     }
1534   /* Now exit the sub mode */
1535   monitor_printf (current_monitor->getreg.term_cmd);
1536   monitor_expect_prompt (NULL, 0);
1537   return written;
1538 }
1539
1540
1541 static int
1542 monitor_write_memory_bytes (memaddr, myaddr, len)
1543      CORE_ADDR memaddr;
1544      char *myaddr;
1545      int len;
1546 {
1547   unsigned char val;
1548   int written = 0;
1549   if (len == 0)
1550     return 0;
1551   /* Enter the sub mode */
1552   monitor_printf (current_monitor->setmem.cmdb, memaddr);
1553   monitor_expect_prompt (NULL, 0);
1554   while (len)
1555     {
1556       val = *myaddr;
1557       monitor_printf ("%x\r", val);
1558       myaddr++;
1559       memaddr++;
1560       written++;
1561       /* If we wanted to, here we could validate the address */
1562       monitor_expect_prompt (NULL, 0);
1563       len--;
1564     }
1565   /* Now exit the sub mode */
1566   monitor_printf (current_monitor->getreg.term_cmd);
1567   monitor_expect_prompt (NULL, 0);
1568   return written;
1569 }
1570
1571
1572 static void
1573 longlongendswap (unsigned char *a)
1574 {
1575   int i, j;
1576   unsigned char x;
1577   i = 0;
1578   j = 7;
1579   while (i < 4)
1580     {
1581       x = *(a + i);
1582       *(a + i) = *(a + j);
1583       *(a + j) = x;
1584       i++, j--;
1585     }
1586 }
1587 /* Format 32 chars of long long value, advance the pointer */
1588 static char *hexlate = "0123456789abcdef";
1589 static char *
1590 longlong_hexchars (unsigned long long value,
1591                    char *outbuff)
1592 {
1593   if (value == 0)
1594     {
1595       *outbuff++ = '0';
1596       return outbuff;
1597     }
1598   else
1599     {
1600       static unsigned char disbuf[8];   /* disassembly buffer */
1601       unsigned char *scan, *limit;      /* loop controls */
1602       unsigned char c, nib;
1603       int leadzero = 1;
1604       scan = disbuf;
1605       limit = scan + 8;
1606       {
1607         unsigned long long *dp;
1608         dp = (unsigned long long *) scan;
1609         *dp = value;
1610       }
1611       longlongendswap (disbuf); /* FIXME: ONly on big endian hosts */
1612       while (scan < limit)
1613         {
1614           c = *scan++;          /* a byte of our long long value */
1615           if (leadzero)
1616             {
1617               if (c == 0)
1618                 continue;
1619               else
1620                 leadzero = 0;   /* henceforth we print even zeroes */
1621             }
1622           nib = c >> 4;         /* high nibble bits */
1623           *outbuff++ = hexlate[nib];
1624           nib = c & 0x0f;       /* low nibble bits */
1625           *outbuff++ = hexlate[nib];
1626         }
1627       return outbuff;
1628     }
1629 }                               /* longlong_hexchars */
1630
1631
1632
1633 /* I am only going to call this when writing virtual byte streams.
1634    Which possably entails endian conversions
1635  */
1636 static int
1637 monitor_write_memory_longlongs (memaddr, myaddr, len)
1638      CORE_ADDR memaddr;
1639      char *myaddr;
1640      int len;
1641 {
1642   static char hexstage[20];     /* At least 16 digits required, plus null */
1643   char *endstring;
1644   long long *llptr;
1645   long long value;
1646   int written = 0;
1647   llptr = (unsigned long long *) myaddr;
1648   if (len == 0)
1649     return 0;
1650   monitor_printf (current_monitor->setmem.cmdll, memaddr);
1651   monitor_expect_prompt (NULL, 0);
1652   while (len >= 8)
1653     {
1654       value = *llptr;
1655       endstring = longlong_hexchars (*llptr, hexstage);
1656       *endstring = '\0';        /* NUll terminate for printf */
1657       monitor_printf ("%s\r", hexstage);
1658       llptr++;
1659       memaddr += 8;
1660       written += 8;
1661       /* If we wanted to, here we could validate the address */
1662       monitor_expect_prompt (NULL, 0);
1663       len -= 8;
1664     }
1665   /* Now exit the sub mode */
1666   monitor_printf (current_monitor->getreg.term_cmd);
1667   monitor_expect_prompt (NULL, 0);
1668   return written;
1669 }                               /* */
1670
1671
1672
1673 /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
1674 /* This is for the large blocks of memory which may occur in downloading.
1675    And for monitors which use interactive entry,
1676    And for monitors which do not have other downloading methods.
1677    Without this, we will end up calling monitor_write_memory many times
1678    and do the entry and exit of the sub mode many times
1679    This currently assumes...
1680    MO_SETMEM_INTERACTIVE
1681    ! MO_NO_ECHO_ON_SETMEM
1682    To use this, the you have to patch the monitor_cmds block with
1683    this function. Otherwise, its not tuned up for use by all
1684    monitor variations.
1685  */
1686
1687 static int
1688 monitor_write_memory_block (memaddr, myaddr, len)
1689      CORE_ADDR memaddr;
1690      char *myaddr;
1691      int len;
1692 {
1693   int written;
1694   written = 0;
1695   /* FIXME: This would be a good place to put the zero test */
1696 #if 1
1697   if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
1698     {
1699       return monitor_write_memory_longlongs (memaddr, myaddr, len);
1700     }
1701 #endif
1702 #if 0
1703   if (len > 4)
1704     {
1705       int sublen;
1706       written = monitor_write_even_block (memaddr, myaddr, len);
1707       /* Adjust calling parameters by written amount */
1708       memaddr += written;
1709       myaddr += written;
1710       len -= written;
1711     }
1712 #endif
1713   written = monitor_write_memory_bytes (memaddr, myaddr, len);
1714   return written;
1715 }
1716
1717 /* This is an alternate form of monitor_read_memory which is used for monitors
1718    which can only read a single byte/word/etc. at a time.  */
1719
1720 static int
1721 monitor_read_memory_single (memaddr, myaddr, len)
1722      CORE_ADDR memaddr;
1723      char *myaddr;
1724      int len;
1725 {
1726   unsigned int val;
1727   char membuf[sizeof (int) * 2 + 1];
1728   char *p;
1729   char *cmd;
1730   int i;
1731
1732   RDEBUG (("MON read single\n"));
1733 #if 0
1734   /* Can't actually use long longs (nice idea, though).  In fact, the
1735      call to strtoul below will fail if it tries to convert a value
1736      that's too big to fit in a long.  */
1737   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
1738     {
1739       len = 8;
1740       cmd = current_monitor->getmem.cmdll;
1741     }
1742   else
1743 #endif
1744   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
1745     {
1746       len = 4;
1747       cmd = current_monitor->getmem.cmdl;
1748     }
1749   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
1750     {
1751       len = 2;
1752       cmd = current_monitor->getmem.cmdw;
1753     }
1754   else
1755     {
1756       len = 1;
1757       cmd = current_monitor->getmem.cmdb;
1758     }
1759
1760   /* Send the examine command.  */
1761
1762   monitor_printf (cmd, memaddr);
1763
1764   /* If RESP_DELIM is specified, we search for that as a leading
1765      delimiter for the memory value.  Otherwise, we just start
1766      searching from the start of the buf.  */
1767
1768   if (current_monitor->getmem.resp_delim)
1769     {
1770       RDEBUG (("EXP getmem.resp_delim\n"));
1771       monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
1772     }
1773
1774   /* Now, read the appropriate number of hex digits for this loc,
1775      skipping spaces.  */
1776
1777   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set. */
1778   if (current_monitor->flags & MO_HEX_PREFIX)
1779     {
1780       int c;
1781
1782       c = readchar (timeout);
1783       while (c == ' ')
1784         c = readchar (timeout);
1785       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
1786         ;
1787       else
1788         monitor_error ("monitor_read_memory_single (0x%x):  bad response from monitor: %.*s%c.",
1789                        memaddr, i, membuf, c);
1790     }
1791   for (i = 0; i < len * 2; i++)
1792     {
1793       int c;
1794
1795       while (1)
1796         {
1797           c = readchar (timeout);
1798           if (isxdigit (c))
1799             break;
1800           if (c == ' ')
1801             continue;
1802
1803           monitor_error ("monitor_read_memory_single (0x%x):  bad response from monitor: %.*s%c.",
1804                          memaddr, i, membuf, c);
1805         }
1806
1807       membuf[i] = c;
1808     }
1809
1810   membuf[i] = '\000';           /* terminate the number */
1811
1812 /* If TERM is present, we wait for that to show up.  Also, (if TERM is
1813    present), we will send TERM_CMD if that is present.  In any case, we collect
1814    all of the output into buf, and then wait for the normal prompt.  */
1815
1816   if (current_monitor->getmem.term)
1817     {
1818       monitor_expect (current_monitor->getmem.term, NULL, 0);   /* get response */
1819
1820       if (current_monitor->getmem.term_cmd)
1821         {
1822           monitor_printf (current_monitor->getmem.term_cmd);
1823           monitor_expect_prompt (NULL, 0);
1824         }
1825     }
1826   else
1827     monitor_expect_prompt (NULL, 0);    /* get response */
1828
1829   p = membuf;
1830   val = strtoul (membuf, &p, 16);
1831
1832   if (val == 0 && membuf == p)
1833     monitor_error ("monitor_read_memory_single (0x%x):  bad value from monitor: %s.",
1834                    memaddr, 0, membuf, 0);
1835
1836   /* supply register stores in target byte order, so swap here */
1837
1838   store_unsigned_integer (myaddr, len, val);
1839
1840   return len;
1841 }
1842
1843 /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
1844    memory at MEMADDR.  Returns length moved.  Currently, we do no more
1845    than 16 bytes at a time.  */
1846
1847 static int
1848 monitor_read_memory (memaddr, myaddr, len)
1849      CORE_ADDR memaddr;
1850      char *myaddr;
1851      int len;
1852 {
1853   unsigned int val;
1854   char buf[512];
1855   char *p, *p1;
1856   int resp_len;
1857   int i;
1858   CORE_ADDR dumpaddr;
1859
1860   if (len <= 0)
1861     {
1862       RDEBUG (("Zero length call to monitor_read_memory\n"));
1863       return 0;
1864     }
1865
1866   if (remote_debug)
1867     printf ("MON read block ta(%08x) ha(%08x) %d\n",
1868             (unsigned long) memaddr, (unsigned long) myaddr, len);
1869
1870   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
1871     memaddr = ADDR_BITS_REMOVE (memaddr);
1872
1873   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
1874     return monitor_read_memory_single (memaddr, myaddr, len);
1875
1876   len = min (len, 16);
1877
1878   /* Some dumpers align the first data with the preceeding 16
1879      byte boundary. Some print blanks and start at the
1880      requested boundary. EXACT_DUMPADDR
1881    */
1882
1883   dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
1884     ? memaddr : memaddr & ~0x0f;
1885
1886   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
1887   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
1888     len = ((memaddr + len) & ~0xf) - memaddr;
1889
1890   /* send the memory examine command */
1891
1892   if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
1893     monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
1894   else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1895     monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
1896   else
1897     monitor_printf (current_monitor->getmem.cmdb, memaddr, len);
1898
1899   /* If TERM is present, we wait for that to show up.  Also, (if TERM
1900      is present), we will send TERM_CMD if that is present.  In any
1901      case, we collect all of the output into buf, and then wait for
1902      the normal prompt.  */
1903
1904   if (current_monitor->getmem.term)
1905     {
1906       resp_len = monitor_expect (current_monitor->getmem.term, buf, sizeof buf);        /* get response */
1907
1908       if (resp_len <= 0)
1909         monitor_error ("monitor_read_memory (0x%x):  excessive response from monitor: %.*s.",
1910                        memaddr, resp_len, buf, 0);
1911
1912       if (current_monitor->getmem.term_cmd)
1913         {
1914           SERIAL_WRITE (monitor_desc, current_monitor->getmem.term_cmd,
1915                         strlen (current_monitor->getmem.term_cmd));
1916           monitor_expect_prompt (NULL, 0);
1917         }
1918     }
1919   else
1920     resp_len = monitor_expect_prompt (buf, sizeof buf);         /* get response */
1921
1922   p = buf;
1923
1924   /* If RESP_DELIM is specified, we search for that as a leading
1925      delimiter for the values.  Otherwise, we just start searching
1926      from the start of the buf.  */
1927
1928   if (current_monitor->getmem.resp_delim)
1929     {
1930       int retval, tmp;
1931       struct re_registers resp_strings;
1932       RDEBUG (("MON getmem.resp_delim %s\n", current_monitor->getmem.resp_delim));
1933
1934       memset (&resp_strings, 0, sizeof (struct re_registers));
1935       tmp = strlen (p);
1936       retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
1937                           &resp_strings);
1938
1939       if (retval < 0)
1940         monitor_error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
1941                        memaddr, resp_len, buf, 0);
1942
1943       p += resp_strings.end[0];
1944 #if 0
1945       p = strstr (p, current_monitor->getmem.resp_delim);
1946       if (!p)
1947         monitor_error ("monitor_read_memory (0x%x):  bad response from monitor: %.*s.",
1948                        memaddr, resp_len, buf, 0);
1949       p += strlen (current_monitor->getmem.resp_delim);
1950 #endif
1951     }
1952   if (remote_debug)
1953     printf ("MON scanning  %d ,%08x '%s'\n", len, p, p);
1954   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
1955     {
1956       char c;
1957       int fetched = 0;
1958       i = len;
1959       c = *p;
1960
1961
1962       while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
1963         {
1964           if (isxdigit (c))
1965             {
1966               if ((dumpaddr >= memaddr) && (i > 0))
1967                 {
1968                   val = fromhex (c) * 16 + fromhex (*(p + 1));
1969                   *myaddr++ = val;
1970                   if (remote_debug)
1971                     printf ("[%02x]", val);
1972                   --i;
1973                   fetched++;
1974                 }
1975               ++dumpaddr;
1976               ++p;
1977             }
1978           ++p;                  /* skip a blank or other non hex char */
1979           c = *p;
1980         }
1981       if (fetched == 0)
1982         error ("Failed to read via monitor");
1983       if (remote_debug)
1984         printf ("\n");
1985       return fetched;           /* Return the number of bytes actually read */
1986     }
1987   RDEBUG (("MON scanning bytes\n"));
1988
1989   for (i = len; i > 0; i--)
1990     {
1991       /* Skip non-hex chars, but bomb on end of string and newlines */
1992
1993       while (1)
1994         {
1995           if (isxdigit (*p))
1996             break;
1997
1998           if (*p == '\000' || *p == '\n' || *p == '\r')
1999             monitor_error ("monitor_read_memory (0x%x):  badly terminated response from monitor: %.*s",
2000                            memaddr, resp_len, buf, 0);
2001           p++;
2002         }
2003
2004       val = strtoul (p, &p1, 16);
2005
2006       if (val == 0 && p == p1)
2007         monitor_error ("monitor_read_memory (0x%x):  bad value from monitor: %.*s.",
2008                        memaddr, resp_len, buf, 0);
2009
2010       *myaddr++ = val;
2011
2012       if (i == 1)
2013         break;
2014
2015       p = p1;
2016     }
2017
2018   return len;
2019 }
2020
2021 static int
2022 monitor_xfer_memory (memaddr, myaddr, len, write, target)
2023      CORE_ADDR memaddr;
2024      char *myaddr;
2025      int len;
2026      int write;
2027      struct target_ops *target; /* ignored */
2028 {
2029   return dcache_xfer_memory (remote_dcache, memaddr, myaddr, len, write);
2030 }
2031
2032 static void
2033 monitor_kill ()
2034 {
2035   return;                       /* ignore attempts to kill target system */
2036 }
2037
2038 /* All we actually do is set the PC to the start address of exec_bfd, and start
2039    the program at that point.  */
2040
2041 static void
2042 monitor_create_inferior (exec_file, args, env)
2043      char *exec_file;
2044      char *args;
2045      char **env;
2046 {
2047   if (args && (*args != '\000'))
2048     error ("Args are not supported by the monitor.");
2049
2050   first_time = 1;
2051   clear_proceed_status ();
2052   proceed (bfd_get_start_address (exec_bfd), TARGET_SIGNAL_0, 0);
2053 }
2054
2055 /* Clean up when a program exits.
2056    The program actually lives on in the remote processor's RAM, and may be
2057    run again without a download.  Don't leave it full of breakpoint
2058    instructions.  */
2059
2060 static void
2061 monitor_mourn_inferior ()
2062 {
2063   unpush_target (targ_ops);
2064   generic_mourn_inferior ();    /* Do all the proper things now */
2065 }
2066
2067 /* Tell the monitor to add a breakpoint.  */
2068
2069 static int
2070 monitor_insert_breakpoint (addr, shadow)
2071      CORE_ADDR addr;
2072      char *shadow;
2073 {
2074   int i;
2075   unsigned char *bp;
2076   int bplen;
2077
2078   RDEBUG (("MON inst bkpt %08x\n", addr))
2079     if (current_monitor->set_break == NULL)
2080     error ("No set_break defined for this monitor");
2081
2082   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2083     addr = ADDR_BITS_REMOVE (addr);
2084
2085   /* Determine appropriate breakpoint size for this address.  */
2086   bp = memory_breakpoint_from_pc (&addr, &bplen);
2087
2088   for (i = 0; i < current_monitor->num_breakpoints; i++)
2089     {
2090       if (breakaddr[i] == 0)
2091         {
2092           breakaddr[i] = addr;
2093           monitor_read_memory (addr, shadow, bplen);
2094           monitor_printf (current_monitor->set_break, addr);
2095           monitor_expect_prompt (NULL, 0);
2096           return 0;
2097         }
2098     }
2099
2100   error ("Too many breakpoints (> %d) for monitor.", current_monitor->num_breakpoints);
2101 }
2102
2103 /* Tell the monitor to remove a breakpoint.  */
2104
2105 static int
2106 monitor_remove_breakpoint (addr, shadow)
2107      CORE_ADDR addr;
2108      char *shadow;
2109 {
2110   int i;
2111
2112   RDEBUG (("MON rmbkpt %08x\n", addr))
2113     if (current_monitor->clr_break == NULL)
2114     error ("No clr_break defined for this monitor");
2115
2116   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
2117     addr = ADDR_BITS_REMOVE (addr);
2118
2119   for (i = 0; i < current_monitor->num_breakpoints; i++)
2120     {
2121       if (breakaddr[i] == addr)
2122         {
2123           breakaddr[i] = 0;
2124           /* some monitors remove breakpoints based on the address */
2125           if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
2126             monitor_printf (current_monitor->clr_break, addr);
2127           else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
2128             monitor_printf (current_monitor->clr_break, i + 1);
2129           else
2130             monitor_printf (current_monitor->clr_break, i);
2131           monitor_expect_prompt (NULL, 0);
2132           return 0;
2133         }
2134     }
2135   fprintf_unfiltered (gdb_stderr,
2136                       "Can't find breakpoint associated with 0x%x\n", addr);
2137   return 1;
2138 }
2139
2140 /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
2141    an S-record.  Return non-zero if the ACK is received properly.  */
2142
2143 static int
2144 monitor_wait_srec_ack ()
2145 {
2146   int i, ch;
2147
2148   if (current_monitor->flags & MO_SREC_ACK_PLUS)
2149     {
2150       return (readchar (timeout) == '+');
2151     }
2152   else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
2153     {
2154       /* Eat two backspaces, a "rotating" char (|/-\), and a space.  */
2155       if ((ch = readchar (1)) < 0)
2156         return 0;
2157       if ((ch = readchar (1)) < 0)
2158         return 0;
2159       if ((ch = readchar (1)) < 0)
2160         return 0;
2161       if ((ch = readchar (1)) < 0)
2162         return 0;
2163     }
2164   return 1;
2165 }
2166
2167 /* monitor_load -- download a file. */
2168
2169 static void
2170 monitor_load (file, from_tty)
2171      char *file;
2172      int from_tty;
2173 {
2174   dcache_flush (remote_dcache);
2175   RDEBUG (("MON load\n"))
2176
2177     if (current_monitor->load_routine)
2178     current_monitor->load_routine (monitor_desc, file, hashmark);
2179   else
2180     {                           /* The default is ascii S-records */
2181       int n;
2182       unsigned long load_offset;
2183       char buf[128];
2184
2185       /* enable user to specify address for downloading as 2nd arg to load */
2186       n = sscanf (file, "%s 0x%lx", buf, &load_offset);
2187       if (n > 1)
2188         file = buf;
2189       else
2190         load_offset = 0;
2191
2192       monitor_printf (current_monitor->load);
2193       if (current_monitor->loadresp)
2194         monitor_expect (current_monitor->loadresp, NULL, 0);
2195
2196       load_srec (monitor_desc, file, (bfd_vma) load_offset,
2197                  32, SREC_ALL, hashmark,
2198                  current_monitor->flags & MO_SREC_ACK ?
2199                  monitor_wait_srec_ack : NULL);
2200
2201       monitor_expect_prompt (NULL, 0);
2202     }
2203
2204 /* Finally, make the PC point at the start address */
2205
2206   if (exec_bfd)
2207     write_pc (bfd_get_start_address (exec_bfd));
2208
2209   inferior_pid = 0;             /* No process now */
2210
2211 /* This is necessary because many things were based on the PC at the time that
2212    we attached to the monitor, which is no longer valid now that we have loaded
2213    new code (and just changed the PC).  Another way to do this might be to call
2214    normal_stop, except that the stack may not be valid, and things would get
2215    horribly confused... */
2216
2217   clear_symtab_users ();
2218 }
2219
2220 static void
2221 monitor_stop ()
2222 {
2223   RDEBUG (("MON stop\n"));
2224   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
2225     SERIAL_SEND_BREAK (monitor_desc);
2226   if (current_monitor->stop)
2227     monitor_printf_noecho (current_monitor->stop);
2228 }
2229
2230 /* Put a command string, in args, out to MONITOR.  Output from MONITOR
2231    is placed on the users terminal until the prompt is seen. FIXME: We
2232    read the characters ourseleves here cause of a nasty echo.  */
2233
2234 static void
2235 monitor_command (args, from_tty)
2236      char *args;
2237      int from_tty;
2238 {
2239   char *p;
2240   int resp_len;
2241   char buf[1000];
2242
2243   if (monitor_desc == NULL)
2244     error ("monitor target not open.");
2245
2246   p = current_monitor->prompt;
2247
2248   /* Send the command.  Note that if no args were supplied, then we're
2249      just sending the monitor a newline, which is sometimes useful.  */
2250
2251   monitor_printf ("%s\r", (args ? args : ""));
2252
2253   resp_len = monitor_expect_prompt (buf, sizeof buf);
2254
2255   fputs_unfiltered (buf, gdb_stdout);   /* Output the response */
2256 }
2257
2258 /* Convert hex digit A to a number.  */
2259
2260 #if 0
2261 static int
2262 from_hex (a)
2263      int a;
2264 {
2265   if (a >= '0' && a <= '9')
2266     return a - '0';
2267   if (a >= 'a' && a <= 'f')
2268     return a - 'a' + 10;
2269   if (a >= 'A' && a <= 'F')
2270     return a - 'A' + 10;
2271
2272   error ("Reply contains invalid hex digit 0x%x", a);
2273 }
2274 #endif
2275
2276 char *
2277 monitor_get_dev_name ()
2278 {
2279   return dev_name;
2280 }
2281
2282 static struct target_ops monitor_ops;
2283
2284 static void
2285 init_base_monitor_ops (void)
2286 {
2287   monitor_ops.to_shortname = NULL;
2288   monitor_ops.to_longname = NULL;
2289   monitor_ops.to_doc = NULL;
2290   monitor_ops.to_open = NULL;
2291   monitor_ops.to_close = monitor_close;
2292   monitor_ops.to_attach = NULL;
2293   monitor_ops.to_post_attach = NULL;
2294   monitor_ops.to_require_attach = NULL;
2295   monitor_ops.to_detach = monitor_detach;
2296   monitor_ops.to_require_detach = NULL;
2297   monitor_ops.to_resume = monitor_resume;
2298   monitor_ops.to_wait = monitor_wait;
2299   monitor_ops.to_post_wait = NULL;
2300   monitor_ops.to_fetch_registers = monitor_fetch_registers;
2301   monitor_ops.to_store_registers = monitor_store_registers;
2302   monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
2303   monitor_ops.to_xfer_memory = monitor_xfer_memory;
2304   monitor_ops.to_files_info = monitor_files_info;
2305   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
2306   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
2307   monitor_ops.to_terminal_init = 0;
2308   monitor_ops.to_terminal_inferior = 0;
2309   monitor_ops.to_terminal_ours_for_output = 0;
2310   monitor_ops.to_terminal_ours = 0;
2311   monitor_ops.to_terminal_info = 0;
2312   monitor_ops.to_kill = monitor_kill;
2313   monitor_ops.to_load = monitor_load;
2314   monitor_ops.to_lookup_symbol = 0;
2315   monitor_ops.to_create_inferior = monitor_create_inferior;
2316   monitor_ops.to_post_startup_inferior = NULL;
2317   monitor_ops.to_acknowledge_created_inferior = NULL;
2318   monitor_ops.to_clone_and_follow_inferior = NULL;
2319   monitor_ops.to_post_follow_inferior_by_clone = NULL;
2320   monitor_ops.to_insert_fork_catchpoint = NULL;
2321   monitor_ops.to_remove_fork_catchpoint = NULL;
2322   monitor_ops.to_insert_vfork_catchpoint = NULL;
2323   monitor_ops.to_remove_vfork_catchpoint = NULL;
2324   monitor_ops.to_has_forked = NULL;
2325   monitor_ops.to_has_vforked = NULL;
2326   monitor_ops.to_can_follow_vfork_prior_to_exec = NULL;
2327   monitor_ops.to_post_follow_vfork = NULL;
2328   monitor_ops.to_insert_exec_catchpoint = NULL;
2329   monitor_ops.to_remove_exec_catchpoint = NULL;
2330   monitor_ops.to_has_execd = NULL;
2331   monitor_ops.to_reported_exec_events_per_exec_call = NULL;
2332   monitor_ops.to_has_exited = NULL;
2333   monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
2334   monitor_ops.to_can_run = 0;
2335   monitor_ops.to_notice_signals = 0;
2336   monitor_ops.to_thread_alive = 0;
2337   monitor_ops.to_stop = monitor_stop;
2338   monitor_ops.to_pid_to_exec_file = NULL;
2339   monitor_ops.to_core_file_to_sym_file = NULL;
2340   monitor_ops.to_stratum = process_stratum;
2341   monitor_ops.DONT_USE = 0;
2342   monitor_ops.to_has_all_memory = 1;
2343   monitor_ops.to_has_memory = 1;
2344   monitor_ops.to_has_stack = 1;
2345   monitor_ops.to_has_registers = 1;
2346   monitor_ops.to_has_execution = 1;
2347   monitor_ops.to_sections = 0;
2348   monitor_ops.to_sections_end = 0;
2349   monitor_ops.to_magic = OPS_MAGIC;
2350 }                               /* init_base_monitor_ops */
2351
2352 /* Init the target_ops structure pointed at by OPS */
2353
2354 void
2355 init_monitor_ops (ops)
2356      struct target_ops *ops;
2357 {
2358   if (monitor_ops.to_magic != OPS_MAGIC)
2359     init_base_monitor_ops ();
2360
2361   memcpy (ops, &monitor_ops, sizeof monitor_ops);
2362 }
2363
2364 /* Define additional commands that are usually only used by monitors.  */
2365
2366 void
2367 _initialize_remote_monitors ()
2368 {
2369   init_base_monitor_ops ();
2370   add_show_from_set (add_set_cmd ("hash", no_class, var_boolean,
2371                                   (char *) &hashmark,
2372                                   "Set display of activity while downloading a file.\n\
2373 When enabled, a hashmark \'#\' is displayed.",
2374                                   &setlist),
2375                      &showlist);
2376
2377   add_com ("monitor", class_obscure, monitor_command,
2378            "Send a command to the debug monitor.");
2379 }