gdb/monitor.c

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