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