gdb/monitor.c

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