gdb/monitor.c

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