gdb/monitor.c - gdb

Global variables defined

Functions defined

Macros defined

Source code

  1. /* Remote debugging interface for boot monitors, for GDB.

  3.    Copyright (C) 1990-2015 Free Software Foundation, Inc.

  5.    Contributed by Cygnus Support.  Written by Rob Savoye for Cygnus.
  6.    Resurrected from the ashes by Stu Grossman.

  8.    This file is part of GDB.

  10.    This program is free software; you can redistribute it and/or modify
  11.    it under the terms of the GNU General Public License as published by
  12.    the Free Software Foundation; either version 3 of the License, or
  13.    (at your option) any later version.

  15.    This program is distributed in the hope that it will be useful,
  16.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.    GNU General Public License for more details.

  20.    You should have received a copy of the GNU General Public License
  21.    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

  23. /* This file was derived from various remote-* modules.  It is a collection
  24.    of generic support functions so GDB can talk directly to a ROM based
  25.    monitor.  This saves use from having to hack an exception based handler
  26.    into existence, and makes for quick porting.

  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.  */

  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  */

  40. #include "defs.h"
  41. #include "gdbcore.h"
  42. #include "target.h"
  43. #include <signal.h>
  44. #include <ctype.h>
  45. #include <sys/types.h>
  46. #include "command.h"
  47. #include "serial.h"
  48. #include "monitor.h"
  49. #include "gdbcmd.h"
  50. #include "inferior.h"
  51. #include "infrun.h"
  52. #include "gdb_regex.h"
  53. #include "srec.h"
  54. #include "regcache.h"
  55. #include "gdbthread.h"
  56. #include "readline/readline.h"

  58. ‌static char *dev_name;
  59. ‌static struct target_ops *targ_ops;

  61. static void monitor_interrupt_query (void);
  62. static void monitor_interrupt_twice (int);
  63. static void monitor_stop (struct target_ops *self, ptid_t);
  64. static void monitor_dump_regs (struct regcache *regcache);

  66. #if 0
  67. static int from_hex (int a);
  68. #endif

  70. ‌static struct monitor_ops *current_monitor;

  72. ‌static int hashmark;                /* flag set by "set hash".  */

  74. ‌static int timeout = 30;

  76. ‌static int in_monitor_wait = 0;        /* Non-zero means we are in monitor_wait().  */

  78. ‌static void (*ofunc) ();        /* Old SIGINT signal handler.  */

  80. ‌static CORE_ADDR *breakaddr;

  82. /* Descriptor for I/O to remote machine.  Initialize it to NULL so
  83.    that monitor_open knows that we don't have a file open when the
  84.    program starts.  */

  86. ‌static struct serial *monitor_desc = NULL;

  88. /* Pointer to regexp pattern matching data.  */

  90. ‌static struct re_pattern_buffer register_pattern;
  91. ‌static char register_fastmap[256];

  93. ‌static struct re_pattern_buffer getmem_resp_delim_pattern;
  94. ‌static char getmem_resp_delim_fastmap[256];

  96. ‌static struct re_pattern_buffer setmem_resp_delim_pattern;
  97. ‌static char setmem_resp_delim_fastmap[256];

  99. ‌static struct re_pattern_buffer setreg_resp_delim_pattern;
  100. ‌static char setreg_resp_delim_fastmap[256];

  102. ‌static int dump_reg_flag;        /* Non-zero means do a dump_registers cmd when
  103.                                    monitor_wait wakes up.  */

  105. ‌static int first_time = 0;        /* Is this the first time we're
  106.                                    executing after gaving created the
  107.                                    child proccess?  */


  110. /* This is the ptid we use while we're connected to a monitor.  Its
  111.    value is arbitrary, as monitor targets don't have a notion of
  112.    processes or threads, but we need something non-null to place in
  113.    inferior_ptid.  */
  114. ‌static ptid_t monitor_ptid;

  116. ‌#define TARGET_BUF_SIZE 2048

  118. /* Monitor specific debugging information.  Typically only useful to
  119.    the developer of a new monitor interface.  */

  121. static void monitor_debug (const char *fmt, ...) ATTRIBUTE_PRINTF (1, 2);

  123. ‌static unsigned int monitor_debug_p = 0;

  125. /* NOTE: This file alternates between monitor_debug_p and remote_debug
  126.    when determining if debug information is printed.  Perhaps this
  127.    could be simplified.  */

  129. static void
  130. ‌monitor_debug (const char *fmt, ...)
  131. {
  132.   if (monitor_debug_p)
  133.     {
  134.       va_list args;

  136.       va_start (args, fmt);
  137.       vfprintf_filtered (gdb_stdlog, fmt, args);
  138.       va_end (args);
  139.     }
  140. }


  143. /* Convert a string into a printable representation, Return # byte in
  144.    the new string.  When LEN is >0 it specifies the size of the
  145.    string.  Otherwize strlen(oldstr) is used.  */

  147. static void
  148. ‌monitor_printable_string (char *newstr, char *oldstr, int len)
  149. {
  150.   int ch;
  151.   int i;

  153.   if (len <= 0)
  154.     len = strlen (oldstr);

  156.   for (i = 0; i < len; i++)
  157.     {
  158.       ch = oldstr[i];
  159.       switch (ch)
  160.         {
  161.         default:
  162.           if (isprint (ch))
  163.             *newstr++ = ch;

  165.           else
  166.             {
  167.               sprintf (newstr, "\\x%02x", ch & 0xff);
  168.               newstr += 4;
  169.             }
  170.           break;

  172.         case '\\':
  173.           *newstr++ = '\\';
  174.           *newstr++ = '\\';
  175.           break;
  176.         case '\b':
  177.           *newstr++ = '\\';
  178.           *newstr++ = 'b';
  179.           break;
  180.         case '\f':
  181.           *newstr++ = '\\';
  182.           *newstr++ = 't';
  183.           break;
  184.         case '\n':
  185.           *newstr++ = '\\';
  186.           *newstr++ = 'n';
  187.           break;
  188.         case '\r':
  189.           *newstr++ = '\\';
  190.           *newstr++ = 'r';
  191.           break;
  192.         case '\t':
  193.           *newstr++ = '\\';
  194.           *newstr++ = 't';
  195.           break;
  196.         case '\v':
  197.           *newstr++ = '\\';
  198.           *newstr++ = 'v';
  199.           break;
  200.         }
  201.     }

  203.   *newstr++ = '\0';
  204. }

  206. /* Print monitor errors with a string, converting the string to printable
  207.    representation.  */

  209. static void
  210. ‌monitor_error (char *function, char *message,
  211.                CORE_ADDR memaddr, int len, char *string, int final_char)
  212. {
  213.   int real_len = (len == 0 && string != (char *) 0) ? strlen (string) : len;
  214.   char *safe_string = alloca ((real_len * 4) + 1);

  216.   monitor_printable_string (safe_string, string, real_len);

  218.   if (final_char)
  219.     error (_("%s (%s): %s: %s%c"),
  220.            function, paddress (target_gdbarch (), memaddr),
  221.            message, safe_string, final_char);
  222.   else
  223.     error (_("%s (%s): %s: %s"),
  224.            function, paddress (target_gdbarch (), memaddr),
  225.            message, safe_string);
  226. }

  228. /* Convert hex digit A to a number.  */

  230. static int
  231. ‌fromhex (int a)
  232. {
  233.   if (a >= '0' && a <= '9')
  234.     return a - '0';
  235.   else if (a >= 'a' && a <= 'f')
  236.     return a - 'a' + 10;
  237.   else if (a >= 'A' && a <= 'F')
  238.     return a - 'A' + 10;
  239.   else
  240.     error (_("Invalid hex digit %d"), a);
  241. }

  243. /* monitor_vsprintf - similar to vsprintf but handles 64-bit addresses

  245.    This function exists to get around the problem that many host platforms
  246.    don't have a printf that can print 64-bit addresses.  The %A format
  247.    specification is recognized as a special case, and causes the argument
  248.    to be printed as a 64-bit hexadecimal address.

  250.    Only format specifiers of the form "[0-9]*[a-z]" are recognized.
  251.    If it is a '%s' format, the argument is a string; otherwise the
  252.    argument is assumed to be a long integer.

  254.    %% is also turned into a single %.  */

  256. static void
  257. ‌monitor_vsprintf (char *sndbuf, char *pattern, va_list args)
  258. {
  259.   int addr_bit = gdbarch_addr_bit (target_gdbarch ());
  260.   char format[10];
  261.   char fmt;
  262.   char *p;
  263.   int i;
  264.   long arg_int;
  265.   CORE_ADDR arg_addr;
  266.   char *arg_string;

  268.   for (p = pattern; *p; p++)
  269.     {
  270.       if (*p == '%')
  271.         {
  272.           /* Copy the format specifier to a separate buffer.  */
  273.           format[0] = *p++;
  274.           for (i = 1; *p >= '0' && *p <= '9' && i < (int) sizeof (format) - 2;
  275.                i++, p++)
  276.             format[i] = *p;
  277.           format[i] = fmt = *p;
  278.           format[i + 1] = '\0';

  280.           /* Fetch the next argument and print it.  */
  281.           switch (fmt)
  282.             {
  283.             case '%':
  284.               strcpy (sndbuf, "%");
  285.               break;
  286.             case 'A':
  287.               arg_addr = va_arg (args, CORE_ADDR);
  288.               strcpy (sndbuf, phex_nz (arg_addr, addr_bit / 8));
  289.               break;
  290.             case 's':
  291.               arg_string = va_arg (args, char *);
  292.               sprintf (sndbuf, format, arg_string);
  293.               break;
  294.             default:
  295.               arg_int = va_arg (args, long);
  296.               sprintf (sndbuf, format, arg_int);
  297.               break;
  298.             }
  299.           sndbuf += strlen (sndbuf);
  300.         }
  301.       else
  302.         *sndbuf++ = *p;
  303.     }
  304.   *sndbuf = '\0';
  305. }


  308. /* monitor_printf_noecho -- Send data to monitor, but don't expect an echo.
  309.    Works just like printf.  */

  311. void
  312. ‌monitor_printf_noecho (char *pattern,...)
  313. {
  314.   va_list args;
  315.   char sndbuf[2000];
  316.   int len;

  318.   va_start (args, pattern);

  320.   monitor_vsprintf (sndbuf, pattern, args);

  322.   len = strlen (sndbuf);
  323.   if (len + 1 > sizeof sndbuf)
  324.     internal_error (__FILE__, __LINE__,
  325.                     _("failed internal consistency check"));

  327.   if (monitor_debug_p)
  328.     {
  329.       char *safe_string = (char *) alloca ((strlen (sndbuf) * 4) + 1);

  331.       monitor_printable_string (safe_string, sndbuf, 0);
  332.       fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
  333.     }

  335.   monitor_write (sndbuf, len);
  336. }

  338. /* monitor_printf -- Send data to monitor and check the echo.  Works just like
  339.    printf.  */

  341. void
  342. ‌monitor_printf (char *pattern,...)
  343. {
  344.   va_list args;
  345.   char sndbuf[2000];
  346.   int len;

  348.   va_start (args, pattern);

  350.   monitor_vsprintf (sndbuf, pattern, args);

  352.   len = strlen (sndbuf);
  353.   if (len + 1 > sizeof sndbuf)
  354.     internal_error (__FILE__, __LINE__,
  355.                     _("failed internal consistency check"));

  357.   if (monitor_debug_p)
  358.     {
  359.       char *safe_string = (char *) alloca ((len * 4) + 1);

  361.       monitor_printable_string (safe_string, sndbuf, 0);
  362.       fprintf_unfiltered (gdb_stdlog, "sent[%s]\n", safe_string);
  363.     }

  365.   monitor_write (sndbuf, len);

  367.   /* We used to expect that the next immediate output was the
  368.      characters we just output, but sometimes some extra junk appeared
  369.      before the characters we expected, like an extra prompt, or a
  370.      portmaster sending telnet negotiations.  So, just start searching
  371.      for what we sent, and skip anything unknown.  */
  372.   monitor_debug ("ExpectEcho\n");
  373.   monitor_expect (sndbuf, (char *) 0, 0);
  374. }


  377. /* Write characters to the remote system.  */

  379. void
  380. ‌monitor_write (char *buf, int buflen)
  381. {
  382.   if (serial_write (monitor_desc, buf, buflen))
  383.     fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n",
  384.                         safe_strerror (errno));
  385. }


  388. /* Read a binary character from the remote system, doing all the fancy
  389.    timeout stuff, but without interpreting the character in any way,
  390.    and without printing remote debug information.  */

  392. int
  393. ‌monitor_readchar (void)
  394. {
  395.   int c;
  396.   int looping;

  398.   do
  399.     {
  400.       looping = 0;
  401.       c = serial_readchar (monitor_desc, timeout);

  403.       if (c >= 0)
  404.         c &= 0xff;                /* don't lose bit 7 */
  405.     }
  406.   while (looping);

  408.   if (c >= 0)
  409.     return c;

  411.   if (c == SERIAL_TIMEOUT)
  412.     error (_("Timeout reading from remote system."));

  414.   perror_with_name (_("remote-monitor"));
  415. }


  418. /* Read a character from the remote system, doing all the fancy
  419.    timeout stuff.  */

  421. static int
  422. ‌readchar (int timeout)
  423. {
  424.   int c;
  425.   static enum
  426.     {
  427.       last_random, last_nl, last_cr, last_crnl
  428.     }
  429.   state = last_random;
  430.   int looping;

  432.   do
  433.     {
  434.       looping = 0;
  435.       c = serial_readchar (monitor_desc, timeout);

  437.       if (c >= 0)
  438.         {
  439.           c &= 0x7f;
  440.           /* This seems to interfere with proper function of the
  441.              input stream.  */
  442.           if (monitor_debug_p || remote_debug)
  443.             {
  444.               char buf[2];

  446.               buf[0] = c;
  447.               buf[1] = '\0';
  448.               puts_debug ("read -->", buf, "<--");
  449.             }

  451.         }

  453.       /* Canonicialize \n\r combinations into one \r.  */
  454.       if ((current_monitor->flags & MO_HANDLE_NL) != 0)
  455.         {
  456.           if ((c == '\r' && state == last_nl)
  457.               || (c == '\n' && state == last_cr))
  458.             {
  459.               state = last_crnl;
  460.               looping = 1;
  461.             }
  462.           else if (c == '\r')
  463.             state = last_cr;
  464.           else if (c != '\n')
  465.             state = last_random;
  466.           else
  467.             {
  468.               state = last_nl;
  469.               c = '\r';
  470.             }
  471.         }
  472.     }
  473.   while (looping);

  475.   if (c >= 0)
  476.     return c;

  478.   if (c == SERIAL_TIMEOUT)
  479. #if 0
  480.     /* I fail to see how detaching here can be useful.  */
  481.     if (in_monitor_wait)        /* Watchdog went off.  */
  482.       {
  483.         target_mourn_inferior ();
  484.         error (_("GDB serial timeout has expired.  Target detached."));
  485.       }
  486.     else
  487. #endif
  488.       error (_("Timeout reading from remote system."));

  490.   perror_with_name (_("remote-monitor"));
  491. }

  493. /* Scan input from the remote system, until STRING is found.  If BUF is non-
  494.    zero, then collect input until we have collected either STRING or BUFLEN-1
  495.    chars.  In either case we terminate BUF with a 0.  If input overflows BUF
  496.    because STRING can't be found, return -1, else return number of chars in BUF
  497.    (minus the terminating NUL).  Note that in the non-overflow case, STRING
  498.    will be at the end of BUF.  */

  500. int
  501. ‌monitor_expect (char *string, char *buf, int buflen)
  502. {
  503.   char *p = string;
  504.   int obuflen = buflen;
  505.   int c;

  507.   if (monitor_debug_p)
  508.     {
  509.       char *safe_string = (char *) alloca ((strlen (string) * 4) + 1);
  510.       monitor_printable_string (safe_string, string, 0);
  511.       fprintf_unfiltered (gdb_stdlog, "MON Expecting '%s'\n", safe_string);
  512.     }

  514.   immediate_quit++;
  515.   QUIT;
  516.   while (1)
  517.     {
  518.       if (buf)
  519.         {
  520.           if (buflen < 2)
  521.             {
  522.               *buf = '\000';
  523.               immediate_quit--;
  524.               return -1;
  525.             }

  527.           c = readchar (timeout);
  528.           if (c == '\000')
  529.             continue;
  530.           *buf++ = c;
  531.           buflen--;
  532.         }
  533.       else
  534.         c = readchar (timeout);

  536.       /* Don't expect any ^C sent to be echoed.  */

  538.       if (*p == '\003' || c == *p)
  539.         {
  540.           p++;
  541.           if (*p == '\0')
  542.             {
  543.               immediate_quit--;

  545.               if (buf)
  546.                 {
  547.                   *buf++ = '\000';
  548.                   return obuflen - buflen;
  549.                 }
  550.               else
  551.                 return 0;
  552.             }
  553.         }
  554.       else
  555.         {
  556.           /* We got a character that doesn't match the string.  We need to
  557.              back up p, but how far?  If we're looking for "..howdy" and the
  558.              monitor sends "...howdy"?  There's certainly a match in there,
  559.              but when we receive the third ".", we won't find it if we just
  560.              restart the matching at the beginning of the string.

  562.              This is a Boyer-Moore kind of situation.  We want to reset P to
  563.              the end of the longest prefix of STRING that is a suffix of
  564.              what we've read so far.  In the example above, that would be
  565.              ".." --- the longest prefix of "..howdy" that is a suffix of
  566.              "...".  This longest prefix could be the empty string, if C
  567.              is nowhere to be found in STRING.

  569.              If this longest prefix is not the empty string, it must contain
  570.              C, so let's search from the end of STRING for instances of C,
  571.              and see if the portion of STRING before that is a suffix of
  572.              what we read before C.  Actually, we can search backwards from
  573.              p, since we know no prefix can be longer than that.

  575.              Note that we can use STRING itself, along with C, as a record
  576.              of what we've received so far.  :)  */
  577.           int i;

  579.           for (i = (p - string) - 1; i >= 0; i--)
  580.             if (string[i] == c)
  581.               {
  582.                 /* Is this prefix a suffix of what we've read so far?
  583.                    In other words, does
  584.                      string[0 .. i-1] == string[p - i, p - 1]?  */
  585.                 if (! memcmp (string, p - i, i))
  586.                   {
  587.                     p = string + i + 1;
  588.                     break;
  589.                   }
  590.               }
  591.           if (i < 0)
  592.             p = string;
  593.         }
  594.     }
  595. }

  597. /* Search for a regexp.  */

  599. static int
  600. ‌monitor_expect_regexp (struct re_pattern_buffer *pat, char *buf, int buflen)
  601. {
  602.   char *mybuf;
  603.   char *p;

  605.   monitor_debug ("MON Expecting regexp\n");
  606.   if (buf)
  607.     mybuf = buf;
  608.   else
  609.     {
  610.       mybuf = alloca (TARGET_BUF_SIZE);
  611.       buflen = TARGET_BUF_SIZE;
  612.     }

  614.   p = mybuf;
  615.   while (1)
  616.     {
  617.       int retval;

  619.       if (p - mybuf >= buflen)
  620.         {                        /* Buffer about to overflow.  */

  622. /* On overflow, we copy the upper half of the buffer to the lower half.  Not
  623.    great, but it usually works...  */

  625.           memcpy (mybuf, mybuf + buflen / 2, buflen / 2);
  626.           p = mybuf + buflen / 2;
  627.         }

  629.       *p++ = readchar (timeout);

  631.       retval = re_search (pat, mybuf, p - mybuf, 0, p - mybuf, NULL);
  632.       if (retval >= 0)
  633.         return 1;
  634.     }
  635. }

  637. /* Keep discarding input until we see the MONITOR prompt.

  639.    The convention for dealing with the prompt is that you
  640.    o give your command
  641.    o *then* wait for the prompt.

  643.    Thus the last thing that a procedure does with the serial line will
  644.    be an monitor_expect_prompt().  Exception: monitor_resume does not
  645.    wait for the prompt, because the terminal is being handed over to
  646.    the inferior.  However, the next thing which happens after that is
  647.    a monitor_wait which does wait for the prompt.  Note that this
  648.    includes abnormal exit, e.g. error().  This is necessary to prevent
  649.    getting into states from which we can't recover.  */

  651. int
  652. ‌monitor_expect_prompt (char *buf, int buflen)
  653. {
  654.   monitor_debug ("MON Expecting prompt\n");
  655.   return monitor_expect (current_monitor->prompt, buf, buflen);
  656. }

  658. /* Get N 32-bit words from remote, each preceded by a space, and put
  659.    them in registers starting at REGNO.  */

  661. #if 0
  662. static unsigned long
  663. get_hex_word (void)
  664. {
  665.   unsigned long val;
  666.   int i;
  667.   int ch;

  669.   do
  670.     ch = readchar (timeout);
  671.   while (isspace (ch));

  673.   val = from_hex (ch);

  675.   for (i = 7; i >= 1; i--)
  676.     {
  677.       ch = readchar (timeout);
  678.       if (!isxdigit (ch))
  679.         break;
  680.       val = (val << 4) | from_hex (ch);
  681.     }

  683.   return val;
  684. }
  685. #endif

  687. static void
  688. ‌compile_pattern (char *pattern, struct re_pattern_buffer *compiled_pattern,
  689.                  char *fastmap)
  690. {
  691.   int tmp;
  692.   const char *val;

  694.   compiled_pattern->fastmap = fastmap;

  696.   tmp = re_set_syntax (RE_SYNTAX_EMACS);
  697.   val = re_compile_pattern (pattern,
  698.                             strlen (pattern),
  699.                             compiled_pattern);
  700.   re_set_syntax (tmp);

  702.   if (val)
  703.     error (_("compile_pattern: Can't compile pattern string `%s': %s!"),
  704.            pattern, val);

  706.   if (fastmap)
  707.     re_compile_fastmap (compiled_pattern);
  708. }

  710. /* Open a connection to a remote debugger.  NAME is the filename used
  711.    for communication.  */

  713. void
  714. ‌monitor_open (const char *args, struct monitor_ops *mon_ops, int from_tty)
  715. {
  716.   const char *name;
  717.   char **p;
  718.   struct inferior *inf;

  720.   if (mon_ops->magic != MONITOR_OPS_MAGIC)
  721.     error (_("Magic number of monitor_ops struct wrong."));

  723.   targ_ops = mon_ops->target;
  724.   name = targ_ops->to_shortname;

  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);

  730.   target_preopen (from_tty);

  732.   /* Setup pattern for register dump.  */

  734.   if (mon_ops->register_pattern)
  735.     compile_pattern (mon_ops->register_pattern, &register_pattern,
  736.                      register_fastmap);

  738.   if (mon_ops->getmem.resp_delim)
  739.     compile_pattern (mon_ops->getmem.resp_delim, &getmem_resp_delim_pattern,
  740.                      getmem_resp_delim_fastmap);

  742.   if (mon_ops->setmem.resp_delim)
  743.     compile_pattern (mon_ops->setmem.resp_delim, &setmem_resp_delim_pattern,
  744.                      setmem_resp_delim_fastmap);

  746.   if (mon_ops->setreg.resp_delim)
  747.     compile_pattern (mon_ops->setreg.resp_delim, &setreg_resp_delim_pattern,
  748.                      setreg_resp_delim_fastmap);

  750.   unpush_target (targ_ops);

  752.   if (dev_name)
  753.     xfree (dev_name);
  754.   dev_name = xstrdup (args);

  756.   monitor_desc = serial_open (dev_name);

  758.   if (!monitor_desc)
  759.     perror_with_name (dev_name);

  761.   if (baud_rate != -1)
  762.     {
  763.       if (serial_setbaudrate (monitor_desc, baud_rate))
  764.         {
  765.           serial_close (monitor_desc);
  766.           perror_with_name (dev_name);
  767.         }
  768.     }

  770.   serial_raw (monitor_desc);

  772.   serial_flush_input (monitor_desc);

  774.   /* some systems only work with 2 stop bits.  */

  776.   serial_setstopbits (monitor_desc, mon_ops->stopbits);

  778.   current_monitor = mon_ops;

  780.   /* See if we can wake up the monitor.  First, try sending a stop sequence,
  781.      then send the init strings.  Last, remove all breakpoints.  */

  783.   if (current_monitor->stop)
  784.     {
  785.       monitor_stop (targ_ops, inferior_ptid);
  786.       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
  787.         {
  788.           monitor_debug ("EXP Open echo\n");
  789.           monitor_expect_prompt (NULL, 0);
  790.         }
  791.     }

  793.   /* wake up the monitor and see if it's alive.  */
  794.   for (p = mon_ops->init; *p != NULL; p++)
  795.     {
  796.       /* Some of the characters we send may not be echoed,
  797.          but we hope to get a prompt at the end of it all.  */

  799.       if ((current_monitor->flags & MO_NO_ECHO_ON_OPEN) == 0)
  800.         monitor_printf (*p);
  801.       else
  802.         monitor_printf_noecho (*p);
  803.       monitor_expect_prompt (NULL, 0);
  804.     }

  806.   serial_flush_input (monitor_desc);

  808.   /* Alloc breakpoints */
  809.   if (mon_ops->set_break != NULL)
  810.     {
  811.       if (mon_ops->num_breakpoints == 0)
  812.         mon_ops->num_breakpoints = 8;

  814.       breakaddr = (CORE_ADDR *)
  815.         xmalloc (mon_ops->num_breakpoints * sizeof (CORE_ADDR));
  816.       memset (breakaddr, 0, mon_ops->num_breakpoints * sizeof (CORE_ADDR));
  817.     }

  819.   /* Remove all breakpoints.  */

  821.   if (mon_ops->clr_all_break)
  822.     {
  823.       monitor_printf (mon_ops->clr_all_break);
  824.       monitor_expect_prompt (NULL, 0);
  825.     }

  827.   if (from_tty)
  828.     printf_unfiltered (_("Remote target %s connected to %s\n"),
  829.                        name, dev_name);

  831.   push_target (targ_ops);

  833.   /* Start afresh.  */
  834.   init_thread_list ();

  836.   /* Make run command think we are busy...  */
  837.   inferior_ptid = monitor_ptid;
  838.   inf = current_inferior ();
  839.   inferior_appeared (inf, ptid_get_pid (inferior_ptid));
  840.   add_thread_silent (inferior_ptid);

  842.   /* Give monitor_wait something to read.  */

  844.   monitor_printf (current_monitor->line_term);

  846.   init_wait_for_inferior ();

  848.   start_remote (from_tty);
  849. }

  851. /* Close out all files and local state before this target loses
  852.    control.  */

  854. void
  855. ‌monitor_close (struct target_ops *self)
  856. {
  857.   if (monitor_desc)
  858.     serial_close (monitor_desc);

  860.   /* Free breakpoint memory.  */
  861.   if (breakaddr != NULL)
  862.     {
  863.       xfree (breakaddr);
  864.       breakaddr = NULL;
  865.     }

  867.   monitor_desc = NULL;

  869.   delete_thread_silent (monitor_ptid);
  870.   delete_inferior_silent (ptid_get_pid (monitor_ptid));
  871. }

  873. /* Terminate the open connection to the remote debugger.  Use this
  874.    when you want to detach and do something else with your gdb.  */

  876. static void
  877. ‌monitor_detach (struct target_ops *ops, const char *args, int from_tty)
  878. {
  879.   unpush_target (ops);                /* calls monitor_close to do the real work.  */
  880.   if (from_tty)
  881.     printf_unfiltered (_("Ending remote %s debugging\n"), target_shortname);
  882. }

  884. /* Convert VALSTR into the target byte-ordered value of REGNO and store it.  */

  886. char *
  887. ‌monitor_supply_register (struct regcache *regcache, int regno, char *valstr)
  888. {
  889.   struct gdbarch *gdbarch = get_regcache_arch (regcache);
  890.   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
  891.   ULONGEST val;
  892.   unsigned char regbuf[MAX_REGISTER_SIZE];
  893.   char *p;

  895.   val = 0;
  896.   p = valstr;
  897.   while (p && *p != '\0')
  898.     {
  899.       if (*p == '\r' || *p == '\n')
  900.         {
  901.           while (*p != '\0')
  902.               p++;
  903.           break;
  904.         }
  905.       if (isspace (*p))
  906.         {
  907.           p++;
  908.           continue;
  909.         }
  910.       if (!isxdigit (*p) && *p != 'x')
  911.         {
  912.           break;
  913.         }

  915.       val <<= 4;
  916.       val += fromhex (*p++);
  917.     }
  918.   monitor_debug ("Supplying Register %d %s\n", regno, valstr);

  920.   if (val == 0 && valstr == p)
  921.     error (_("monitor_supply_register (%d):  bad value from monitor: %s."),
  922.            regno, valstr);

  924.   /* supply register stores in target byte order, so swap here.  */

  926.   store_unsigned_integer (regbuf, register_size (gdbarch, regno), byte_order,
  927.                           val);

  929.   regcache_raw_supply (regcache, regno, regbuf);

  931.   return p;
  932. }

  934. /* Tell the remote machine to resume.  */

  936. static void
  937. ‌monitor_resume (struct target_ops *ops,
  938.                 ptid_t ptid, int step, enum gdb_signal sig)
  939. {
  940.   /* Some monitors require a different command when starting a program.  */
  941.   monitor_debug ("MON resume\n");
  942.   if (current_monitor->flags & MO_RUN_FIRST_TIME && first_time == 1)
  943.     {
  944.       first_time = 0;
  945.       monitor_printf ("run\r");
  946.       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
  947.         dump_reg_flag = 1;
  948.       return;
  949.     }
  950.   if (step)
  951.     monitor_printf (current_monitor->step);
  952.   else
  953.     {
  954.       if (current_monitor->continue_hook)
  955.         (*current_monitor->continue_hook) ();
  956.       else
  957.         monitor_printf (current_monitor->cont);
  958.       if (current_monitor->flags & MO_NEED_REGDUMP_AFTER_CONT)
  959.         dump_reg_flag = 1;
  960.     }
  961. }

  963. /* Parse the output of a register dump command.  A monitor specific
  964.    regexp is used to extract individual register descriptions of the
  965.    form REG=VAL.  Each description is split up into a name and a value
  966.    string which are passed down to monitor specific code.  */

  968. static void
  969. ‌parse_register_dump (struct regcache *regcache, char *buf, int len)
  970. {
  971.   monitor_debug ("MON Parsing  register dump\n");
  972.   while (1)
  973.     {
  974.       int regnamelen, vallen;
  975.       char *regname, *val;

  977.       /* Element 0 points to start of register name, and element 1
  978.          points to the start of the register value.  */
  979.       struct re_registers register_strings;

  981.       memset (&register_strings, 0, sizeof (struct re_registers));

  983.       if (re_search (&register_pattern, buf, len, 0, len,
  984.                      &register_strings) == -1)
  985.         break;

  987.       regnamelen = register_strings.end[1] - register_strings.start[1];
  988.       regname = buf + register_strings.start[1];
  989.       vallen = register_strings.end[2] - register_strings.start[2];
  990.       val = buf + register_strings.start[2];

  992.       current_monitor->supply_register (regcache, regname, regnamelen,
  993.                                         val, vallen);

  995.       buf += register_strings.end[0];
  996.       len -= register_strings.end[0];
  997.     }
  998. }

  1000. /* Send ^C to target to halt it.  Target will respond, and send us a
  1001.    packet.  */

  1003. static void
  1004. ‌monitor_interrupt (int signo)
  1005. {
  1006.   /* If this doesn't work, try more severe steps.  */
  1007.   signal (signo, monitor_interrupt_twice);

  1009.   if (monitor_debug_p || remote_debug)
  1010.     fprintf_unfiltered (gdb_stdlog, "monitor_interrupt called\n");

  1012.   target_stop (inferior_ptid);
  1013. }

  1015. /* The user typed ^C twice.  */

  1017. static void
  1018. ‌monitor_interrupt_twice (int signo)
  1019. {
  1020.   signal (signo, ofunc);

  1022.   monitor_interrupt_query ();

  1024.   signal (signo, monitor_interrupt);
  1025. }

  1027. /* Ask the user what to do when an interrupt is received.  */

  1029. static void
  1030. ‌monitor_interrupt_query (void)
  1031. {
  1032.   target_terminal_ours ();

  1034.   if (query (_("Interrupted while waiting for the program.\n\
  1035. Give up (and stop debugging it)? ")))
  1036.     {
  1037.       target_mourn_inferior ();
  1038.       quit ();
  1039.     }

  1041.   target_terminal_inferior ();
  1042. }

  1044. static void
  1045. ‌monitor_wait_cleanup (void *old_timeout)
  1046. {
  1047.   timeout = *(int *) old_timeout;
  1048.   signal (SIGINT, ofunc);
  1049.   in_monitor_wait = 0;
  1050. }



  1054. static void
  1055. ‌monitor_wait_filter (char *buf,
  1056.                      int bufmax,
  1057.                      int *ext_resp_len,
  1058.                      struct target_waitstatus *status)
  1059. {
  1060.   int resp_len;

  1062.   do
  1063.     {
  1064.       resp_len = monitor_expect_prompt (buf, bufmax);
  1065.       *ext_resp_len = resp_len;

  1067.       if (resp_len <= 0)
  1068.         fprintf_unfiltered (gdb_stderr,
  1069.                             "monitor_wait:  excessive "
  1070.                             "response from monitor: %s.", buf);
  1071.     }
  1072.   while (resp_len < 0);

  1074.   /* Print any output characters that were preceded by ^O.  */
  1075.   /* FIXME - This would be great as a user settabgle flag.  */
  1076.   if (monitor_debug_p || remote_debug
  1077.       || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
  1078.     {
  1079.       int i;

  1081.       for (i = 0; i < resp_len - 1; i++)
  1082.         if (buf[i] == 0x0f)
  1083.           putchar_unfiltered (buf[++i]);
  1084.     }
  1085. }



  1089. /* Wait until the remote machine stops, then return, storing status in
  1090.    status just as `wait' would.  */

  1092. static ptid_t
  1093. ‌monitor_wait (struct target_ops *ops,
  1094.               ptid_t ptid, struct target_waitstatus *status, int options)
  1095. {
  1096.   int old_timeout = timeout;
  1097.   char buf[TARGET_BUF_SIZE];
  1098.   int resp_len;
  1099.   struct cleanup *old_chain;

  1101.   status->kind = TARGET_WAITKIND_EXITED;
  1102.   status->value.integer = 0;

  1104.   old_chain = make_cleanup (monitor_wait_cleanup, &old_timeout);
  1105.   monitor_debug ("MON wait\n");

  1107. #if 0
  1108.   /* This is somthing other than a maintenance command.  */
  1109.     in_monitor_wait = 1;
  1110.   timeout = watchdog > 0 ? watchdog : -1;
  1111. #else
  1112.   timeout = -1;                /* Don't time out -- user program is running.  */
  1113. #endif

  1115.   ofunc = (void (*)()) signal (SIGINT, monitor_interrupt);

  1117.   if (current_monitor->wait_filter)
  1118.     (*current_monitor->wait_filter) (buf, sizeof (buf), &resp_len, status);
  1119.   else
  1120.     monitor_wait_filter (buf, sizeof (buf), &resp_len, status);

  1122. #if 0                                /* Transferred to monitor wait filter.  */
  1123.   do
  1124.     {
  1125.       resp_len = monitor_expect_prompt (buf, sizeof (buf));

  1127.       if (resp_len <= 0)
  1128.         fprintf_unfiltered (gdb_stderr,
  1129.                             "monitor_wait:  excessive "
  1130.                             "response from monitor: %s.", buf);
  1131.     }
  1132.   while (resp_len < 0);

  1134.   /* Print any output characters that were preceded by ^O.  */
  1135.   /* FIXME - This would be great as a user settabgle flag.  */
  1136.   if (monitor_debug_p || remote_debug
  1137.       || current_monitor->flags & MO_PRINT_PROGRAM_OUTPUT)
  1138.     {
  1139.       int i;

  1141.       for (i = 0; i < resp_len - 1; i++)
  1142.         if (buf[i] == 0x0f)
  1143.           putchar_unfiltered (buf[++i]);
  1144.     }
  1145. #endif

  1147.   signal (SIGINT, ofunc);

  1149.   timeout = old_timeout;
  1150. #if 0
  1151.   if (dump_reg_flag && current_monitor->dump_registers)
  1152.     {
  1153.       dump_reg_flag = 0;
  1154.       monitor_printf (current_monitor->dump_registers);
  1155.       resp_len = monitor_expect_prompt (buf, sizeof (buf));
  1156.     }

  1158.   if (current_monitor->register_pattern)
  1159.     parse_register_dump (get_current_regcache (), buf, resp_len);
  1160. #else
  1161.   monitor_debug ("Wait fetching registers after stop\n");
  1162.   monitor_dump_regs (get_current_regcache ());
  1163. #endif

  1165.   status->kind = TARGET_WAITKIND_STOPPED;
  1166.   status->value.sig = GDB_SIGNAL_TRAP;

  1168.   discard_cleanups (old_chain);

  1170.   in_monitor_wait = 0;

  1172.   return inferior_ptid;
  1173. }

  1175. /* Fetch register REGNO, or all registers if REGNO is -1.  Returns
  1176.    errno value.  */

  1178. static void
  1179. ‌monitor_fetch_register (struct regcache *regcache, int regno)
  1180. {
  1181.   const char *name;
  1182.   char *zerobuf;
  1183.   char *regbuf;
  1184.   int i;

  1186.   regbuf  = alloca (MAX_REGISTER_SIZE * 2 + 1);
  1187.   zerobuf = alloca (MAX_REGISTER_SIZE);
  1188.   memset (zerobuf, 0, MAX_REGISTER_SIZE);

  1190.   if (current_monitor->regname != NULL)
  1191.     name = current_monitor->regname (regno);
  1192.   else
  1193.     name = current_monitor->regnames[regno];
  1194.   monitor_debug ("MON fetchreg %d '%s'\n", regno, name ? name : "(null name)");

  1196.   if (!name || (*name == '\0'))
  1197.     {
  1198.       monitor_debug ("No register known for %d\n", regno);
  1199.       regcache_raw_supply (regcache, regno, zerobuf);
  1200.       return;
  1201.     }

  1203.   /* Send the register examine command.  */

  1205.   monitor_printf (current_monitor->getreg.cmd, name);

  1207.   /* If RESP_DELIM is specified, we search for that as a leading
  1208.      delimiter for the register value.  Otherwise, we just start
  1209.      searching from the start of the buf.  */

  1211.   if (current_monitor->getreg.resp_delim)
  1212.     {
  1213.       monitor_debug ("EXP getreg.resp_delim\n");
  1214.       monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
  1215.       /* Handle case of first 32 registers listed in pairs.  */
  1216.       if (current_monitor->flags & MO_32_REGS_PAIRED
  1217.           && (regno & 1) != 0 && regno < 32)
  1218.         {
  1219.           monitor_debug ("EXP getreg.resp_delim\n");
  1220.           monitor_expect (current_monitor->getreg.resp_delim, NULL, 0);
  1221.         }
  1222.     }

  1224.   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set.  */
  1225.   if (current_monitor->flags & MO_HEX_PREFIX)
  1226.     {
  1227.       int c;

  1229.       c = readchar (timeout);
  1230.       while (c == ' ')
  1231.         c = readchar (timeout);
  1232.       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
  1233.         ;
  1234.       else
  1235.         error (_("Bad value returned from monitor "
  1236.                  "while fetching register %x."),
  1237.                regno);
  1238.     }

  1240.   /* Read upto the maximum number of hex digits for this register, skipping
  1241.      spaces, but stop reading if something else is seen.  Some monitors
  1242.      like to drop leading zeros.  */

  1244.   for (i = 0; i < register_size (get_regcache_arch (regcache), regno) * 2; i++)
  1245.     {
  1246.       int c;

  1248.       c = readchar (timeout);
  1249.       while (c == ' ')
  1250.         c = readchar (timeout);

  1252.       if (!isxdigit (c))
  1253.         break;

  1255.       regbuf[i] = c;
  1256.     }

  1258.   regbuf[i] = '\000';                /* Terminate the number.  */
  1259.   monitor_debug ("REGVAL '%s'\n", regbuf);

  1261.   /* If TERM is present, we wait for that to show up.  Also, (if TERM
  1262.      is present), we will send TERM_CMD if that is present.  In any
  1263.      case, we collect all of the output into buf, and then wait for
  1264.      the normal prompt.  */

  1266.   if (current_monitor->getreg.term)
  1267.     {
  1268.       monitor_debug ("EXP getreg.term\n");
  1269.       monitor_expect (current_monitor->getreg.term, NULL, 0); /* Get
  1270.                                                                  response.  */
  1271.     }

  1273.   if (current_monitor->getreg.term_cmd)
  1274.     {
  1275.       monitor_debug ("EMIT getreg.term.cmd\n");
  1276.       monitor_printf (current_monitor->getreg.term_cmd);
  1277.     }
  1278.   if (!current_monitor->getreg.term ||        /* Already expected or */
  1279.       current_monitor->getreg.term_cmd)                /* ack expected.  */
  1280.     monitor_expect_prompt (NULL, 0);        /* Get response.  */

  1282.   monitor_supply_register (regcache, regno, regbuf);
  1283. }

  1285. /* Sometimes, it takes several commands to dump the registers.  */
  1286. /* This is a primitive for use by variations of monitor interfaces in
  1287.    case they need to compose the operation.  */

  1289. int
  1290. ‌monitor_dump_reg_block (struct regcache *regcache, char *block_cmd)
  1291. {
  1292.   char buf[TARGET_BUF_SIZE];
  1293.   int resp_len;

  1295.   monitor_printf (block_cmd);
  1296.   resp_len = monitor_expect_prompt (buf, sizeof (buf));
  1297.   parse_register_dump (regcache, buf, resp_len);
  1298.   return 1;
  1299. }


  1302. /* Read the remote registers into the block regs.  */
  1303. /* Call the specific function if it has been provided.  */

  1305. static void
  1306. ‌monitor_dump_regs (struct regcache *regcache)
  1307. {
  1308.   char buf[TARGET_BUF_SIZE];
  1309.   int resp_len;

  1311.   if (current_monitor->dumpregs)
  1312.     (*(current_monitor->dumpregs)) (regcache);        /* Call supplied function.  */
  1313.   else if (current_monitor->dump_registers)        /* Default version.  */
  1314.     {
  1315.       monitor_printf (current_monitor->dump_registers);
  1316.       resp_len = monitor_expect_prompt (buf, sizeof (buf));
  1317.       parse_register_dump (regcache, buf, resp_len);
  1318.     }
  1319.   else
  1320.     /* Need some way to read registers.  */
  1321.     internal_error (__FILE__, __LINE__,
  1322.                     _("failed internal consistency check"));
  1323. }

  1325. static void
  1326. ‌monitor_fetch_registers (struct target_ops *ops,
  1327.                          struct regcache *regcache, int regno)
  1328. {
  1329.   monitor_debug ("MON fetchregs\n");
  1330.   if (current_monitor->getreg.cmd)
  1331.     {
  1332.       if (regno >= 0)
  1333.         {
  1334.           monitor_fetch_register (regcache, regno);
  1335.           return;
  1336.         }

  1338.       for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
  1339.            regno++)
  1340.         monitor_fetch_register (regcache, regno);
  1341.     }
  1342.   else
  1343.     {
  1344.       monitor_dump_regs (regcache);
  1345.     }
  1346. }

  1348. /* Store register REGNO, or all if REGNO == 0.  Return errno value.  */

  1350. static void
  1351. ‌monitor_store_register (struct regcache *regcache, int regno)
  1352. {
  1353.   int reg_size = register_size (get_regcache_arch (regcache), regno);
  1354.   const char *name;
  1355.   ULONGEST val;

  1357.   if (current_monitor->regname != NULL)
  1358.     name = current_monitor->regname (regno);
  1359.   else
  1360.     name = current_monitor->regnames[regno];

  1362.   if (!name || (*name == '\0'))
  1363.     {
  1364.       monitor_debug ("MON Cannot store unknown register\n");
  1365.       return;
  1366.     }

  1368.   regcache_cooked_read_unsigned (regcache, regno, &val);
  1369.   monitor_debug ("MON storeg %d %s\n", regno, phex (val, reg_size));

  1371.   /* Send the register deposit command.  */

  1373.   if (current_monitor->flags & MO_REGISTER_VALUE_FIRST)
  1374.     monitor_printf (current_monitor->setreg.cmd, val, name);
  1375.   else if (current_monitor->flags & MO_SETREG_INTERACTIVE)
  1376.     monitor_printf (current_monitor->setreg.cmd, name);
  1377.   else
  1378.     monitor_printf (current_monitor->setreg.cmd, name, val);

  1380.   if (current_monitor->setreg.resp_delim)
  1381.     {
  1382.       monitor_debug ("EXP setreg.resp_delim\n");
  1383.       monitor_expect_regexp (&setreg_resp_delim_pattern, NULL, 0);
  1384.       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
  1385.         monitor_printf ("%s\r", phex_nz (val, reg_size));
  1386.     }
  1387.   if (current_monitor->setreg.term)
  1388.     {
  1389.       monitor_debug ("EXP setreg.term\n");
  1390.       monitor_expect (current_monitor->setreg.term, NULL, 0);
  1391.       if (current_monitor->flags & MO_SETREG_INTERACTIVE)
  1392.         monitor_printf ("%s\r", phex_nz (val, reg_size));
  1393.       monitor_expect_prompt (NULL, 0);
  1394.     }
  1395.   else
  1396.     monitor_expect_prompt (NULL, 0);
  1397.   if (current_monitor->setreg.term_cmd)                /* Mode exit required.  */
  1398.     {
  1399.       monitor_debug ("EXP setreg_termcmd\n");
  1400.       monitor_printf ("%s", current_monitor->setreg.term_cmd);
  1401.       monitor_expect_prompt (NULL, 0);
  1402.     }
  1403. }                                /* monitor_store_register */

  1405. /* Store the remote registers.  */

  1407. static void
  1408. ‌monitor_store_registers (struct target_ops *ops,
  1409.                          struct regcache *regcache, int regno)
  1410. {
  1411.   if (regno >= 0)
  1412.     {
  1413.       monitor_store_register (regcache, regno);
  1414.       return;
  1415.     }

  1417.   for (regno = 0; regno < gdbarch_num_regs (get_regcache_arch (regcache));
  1418.        regno++)
  1419.     monitor_store_register (regcache, regno);
  1420. }

  1422. /* Get ready to modify the registers array.  On machines which store
  1423.    individual registers, this doesn't need to do anything.  On machines
  1424.    which store all the registers in one fell swoop, this makes sure
  1425.    that registers contains all the registers from the program being
  1426.    debugged.  */

  1428. static void
  1429. ‌monitor_prepare_to_store (struct target_ops *self, struct regcache *regcache)
  1430. {
  1431.   /* Do nothing, since we can store individual regs.  */
  1432. }

  1434. static void
  1435. ‌monitor_files_info (struct target_ops *ops)
  1436. {
  1437.   printf_unfiltered (_("\tAttached to %s at %d baud.\n"), dev_name, baud_rate);
  1438. }

  1440. static int
  1441. ‌monitor_write_memory (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
  1442. {
  1443.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  1444.   unsigned int val, hostval;
  1445.   char *cmd;
  1446.   int i;

  1448.   monitor_debug ("MON write %d %s\n", len, paddress (target_gdbarch (), memaddr));

  1450.   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
  1451.     memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);

  1453.   /* Use memory fill command for leading 0 bytes.  */

  1455.   if (current_monitor->fill)
  1456.     {
  1457.       for (i = 0; i < len; i++)
  1458.         if (myaddr[i] != 0)
  1459.           break;

  1461.       if (i > 4)                /* More than 4 zeros is worth doing.  */
  1462.         {
  1463.           monitor_debug ("MON FILL %d\n", i);
  1464.           if (current_monitor->flags & MO_FILL_USES_ADDR)
  1465.             monitor_printf (current_monitor->fill, memaddr,
  1466.                             (memaddr + i) - 1, 0);
  1467.           else
  1468.             monitor_printf (current_monitor->fill, memaddr, i, 0);

  1470.           monitor_expect_prompt (NULL, 0);

  1472.           return i;
  1473.         }
  1474.     }

  1476. #if 0
  1477.   /* Can't actually use long longs if VAL is an int (nice idea, though).  */
  1478.   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->setmem.cmdll)
  1479.     {
  1480.       len = 8;
  1481.       cmd = current_monitor->setmem.cmdll;
  1482.     }
  1483.   else
  1484. #endif
  1485.   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->setmem.cmdl)
  1486.     {
  1487.       len = 4;
  1488.       cmd = current_monitor->setmem.cmdl;
  1489.     }
  1490.   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->setmem.cmdw)
  1491.     {
  1492.       len = 2;
  1493.       cmd = current_monitor->setmem.cmdw;
  1494.     }
  1495.   else
  1496.     {
  1497.       len = 1;
  1498.       cmd = current_monitor->setmem.cmdb;
  1499.     }

  1501.   val = extract_unsigned_integer (myaddr, len, byte_order);

  1503.   if (len == 4)
  1504.     {
  1505.       hostval = *(unsigned int *) myaddr;
  1506.       monitor_debug ("Hostval(%08x) val(%08x)\n", hostval, val);
  1507.     }


  1510.   if (current_monitor->flags & MO_NO_ECHO_ON_SETMEM)
  1511.     monitor_printf_noecho (cmd, memaddr, val);
  1512.   else if (current_monitor->flags & MO_SETMEM_INTERACTIVE)
  1513.     {
  1514.       monitor_printf_noecho (cmd, memaddr);

  1516.       if (current_monitor->setmem.resp_delim)
  1517.         {
  1518.           monitor_debug ("EXP setmem.resp_delim");
  1519.           monitor_expect_regexp (&setmem_resp_delim_pattern, NULL, 0);
  1520.           monitor_printf ("%x\r", val);
  1521.        }
  1522.       if (current_monitor->setmem.term)
  1523.         {
  1524.           monitor_debug ("EXP setmem.term");
  1525.           monitor_expect (current_monitor->setmem.term, NULL, 0);
  1526.           monitor_printf ("%x\r", val);
  1527.         }
  1528.       if (current_monitor->setmem.term_cmd)
  1529.         {        /* Emit this to get out of the memory editing state.  */
  1530.           monitor_printf ("%s", current_monitor->setmem.term_cmd);
  1531.           /* Drop through to expecting a prompt.  */
  1532.         }
  1533.     }
  1534.   else
  1535.     monitor_printf (cmd, memaddr, val);

  1537.   monitor_expect_prompt (NULL, 0);

  1539.   return len;
  1540. }


  1543. static int
  1544. ‌monitor_write_memory_bytes (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
  1545. {
  1546.   unsigned char val;
  1547.   int written = 0;

  1549.   if (len == 0)
  1550.     return 0;
  1551.   /* Enter the sub mode.  */
  1552.   monitor_printf (current_monitor->setmem.cmdb, memaddr);
  1553.   monitor_expect_prompt (NULL, 0);
  1554.   while (len)
  1555.     {
  1556.       val = *myaddr;
  1557.       monitor_printf ("%x\r", val);
  1558.       myaddr++;
  1559.       memaddr++;
  1560.       written++;
  1561.       /* If we wanted to, here we could validate the address.  */
  1562.       monitor_expect_prompt (NULL, 0);
  1563.       len--;
  1564.     }
  1565.   /* Now exit the sub mode.  */
  1566.   monitor_printf (current_monitor->getreg.term_cmd);
  1567.   monitor_expect_prompt (NULL, 0);
  1568.   return written;
  1569. }


  1572. static void
  1573. ‌longlongendswap (unsigned char *a)
  1574. {
  1575.   int i, j;
  1576.   unsigned char x;

  1578.   i = 0;
  1579.   j = 7;
  1580.   while (i < 4)
  1581.     {
  1582.       x = *(a + i);
  1583.       *(a + i) = *(a + j);
  1584.       *(a + j) = x;
  1585.       i++, j--;
  1586.     }
  1587. }
  1588. /* Format 32 chars of long long value, advance the pointer.  */
  1589. ‌static char *hexlate = "0123456789abcdef";
  1590. static char *
  1591. ‌longlong_hexchars (unsigned long long value,
  1592.                    char *outbuff)
  1593. {
  1594.   if (value == 0)
  1595.     {
  1596.       *outbuff++ = '0';
  1597.       return outbuff;
  1598.     }
  1599.   else
  1600.     {
  1601.       static unsigned char disbuf[8];        /* disassembly buffer */
  1602.       unsigned char *scan, *limit;        /* loop controls */
  1603.       unsigned char c, nib;
  1604.       int leadzero = 1;

  1606.       scan = disbuf;
  1607.       limit = scan + 8;
  1608.       {
  1609.         unsigned long long *dp;

  1611.         dp = (unsigned long long *) scan;
  1612.         *dp = value;
  1613.       }
  1614.       longlongendswap (disbuf);        /* FIXME: ONly on big endian hosts.  */
  1615.       while (scan < limit)
  1616.         {
  1617.           c = *scan++;                /* A byte of our long long value.  */
  1618.           if (leadzero)
  1619.             {
  1620.               if (c == 0)
  1621.                 continue;
  1622.               else
  1623.                 leadzero = 0;        /* Henceforth we print even zeroes.  */
  1624.             }
  1625.           nib = c >> 4;                /* high nibble bits */
  1626.           *outbuff++ = hexlate[nib];
  1627.           nib = c & 0x0f;        /* low nibble bits */
  1628.           *outbuff++ = hexlate[nib];
  1629.         }
  1630.       return outbuff;
  1631.     }
  1632. }                                /* longlong_hexchars */



  1636. /* I am only going to call this when writing virtual byte streams.
  1637.    Which possably entails endian conversions.  */

  1639. static int
  1640. ‌monitor_write_memory_longlongs (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
  1641. {
  1642.   static char hexstage[20];        /* At least 16 digits required, plus null.  */
  1643.   char *endstring;
  1644.   long long *llptr;
  1645.   long long value;
  1646.   int written = 0;

  1648.   llptr = (long long *) myaddr;
  1649.   if (len == 0)
  1650.     return 0;
  1651.   monitor_printf (current_monitor->setmem.cmdll, memaddr);
  1652.   monitor_expect_prompt (NULL, 0);
  1653.   while (len >= 8)
  1654.     {
  1655.       value = *llptr;
  1656.       endstring = longlong_hexchars (*llptr, hexstage);
  1657.       *endstring = '\0';        /* NUll terminate for printf.  */
  1658.       monitor_printf ("%s\r", hexstage);
  1659.       llptr++;
  1660.       memaddr += 8;
  1661.       written += 8;
  1662.       /* If we wanted to, here we could validate the address.  */
  1663.       monitor_expect_prompt (NULL, 0);
  1664.       len -= 8;
  1665.     }
  1666.   /* Now exit the sub mode.  */
  1667.   monitor_printf (current_monitor->getreg.term_cmd);
  1668.   monitor_expect_prompt (NULL, 0);
  1669.   return written;
  1670. }                                /* */



  1674. /* ----- MONITOR_WRITE_MEMORY_BLOCK ---------------------------- */
  1675. /* This is for the large blocks of memory which may occur in downloading.
  1676.    And for monitors which use interactive entry,
  1677.    And for monitors which do not have other downloading methods.
  1678.    Without this, we will end up calling monitor_write_memory many times
  1679.    and do the entry and exit of the sub mode many times
  1680.    This currently assumes...
  1681.    MO_SETMEM_INTERACTIVE
  1682.    ! MO_NO_ECHO_ON_SETMEM
  1683.    To use this, the you have to patch the monitor_cmds block with
  1684.    this function.  Otherwise, its not tuned up for use by all
  1685.    monitor variations.  */

  1687. static int
  1688. ‌monitor_write_memory_block (CORE_ADDR memaddr, const gdb_byte *myaddr, int len)
  1689. {
  1690.   int written;

  1692.   written = 0;
  1693.   /* FIXME: This would be a good place to put the zero test.  */
  1694. #if 1
  1695.   if ((len > 8) && (((len & 0x07)) == 0) && current_monitor->setmem.cmdll)
  1696.     {
  1697.       return monitor_write_memory_longlongs (memaddr, myaddr, len);
  1698.     }
  1699. #endif
  1700.   written = monitor_write_memory_bytes (memaddr, myaddr, len);
  1701.   return written;
  1702. }

  1704. /* This is an alternate form of monitor_read_memory which is used for monitors
  1705.    which can only read a single byte/word/etc. at a time.  */

  1707. static int
  1708. ‌monitor_read_memory_single (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
  1709. {
  1710.   enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ());
  1711.   unsigned int val;
  1712.   char membuf[sizeof (int) * 2 + 1];
  1713.   char *p;
  1714.   char *cmd;

  1716.   monitor_debug ("MON read single\n");
  1717. #if 0
  1718.   /* Can't actually use long longs (nice idea, though).  In fact, the
  1719.      call to strtoul below will fail if it tries to convert a value
  1720.      that's too big to fit in a long.  */
  1721.   if ((memaddr & 0x7) == 0 && len >= 8 && current_monitor->getmem.cmdll)
  1722.     {
  1723.       len = 8;
  1724.       cmd = current_monitor->getmem.cmdll;
  1725.     }
  1726.   else
  1727. #endif
  1728.   if ((memaddr & 0x3) == 0 && len >= 4 && current_monitor->getmem.cmdl)
  1729.     {
  1730.       len = 4;
  1731.       cmd = current_monitor->getmem.cmdl;
  1732.     }
  1733.   else if ((memaddr & 0x1) == 0 && len >= 2 && current_monitor->getmem.cmdw)
  1734.     {
  1735.       len = 2;
  1736.       cmd = current_monitor->getmem.cmdw;
  1737.     }
  1738.   else
  1739.     {
  1740.       len = 1;
  1741.       cmd = current_monitor->getmem.cmdb;
  1742.     }

  1744.   /* Send the examine command.  */

  1746.   monitor_printf (cmd, memaddr);

  1748.   /* If RESP_DELIM is specified, we search for that as a leading
  1749.      delimiter for the memory value.  Otherwise, we just start
  1750.      searching from the start of the buf.  */

  1752.   if (current_monitor->getmem.resp_delim)
  1753.     {
  1754.       monitor_debug ("EXP getmem.resp_delim\n");
  1755.       monitor_expect_regexp (&getmem_resp_delim_pattern, NULL, 0);
  1756.     }

  1758.   /* Now, read the appropriate number of hex digits for this loc,
  1759.      skipping spaces.  */

  1761.   /* Skip leading spaces and "0x" if MO_HEX_PREFIX flag is set.  */
  1762.   if (current_monitor->flags & MO_HEX_PREFIX)
  1763.     {
  1764.       int c;

  1766.       c = readchar (timeout);
  1767.       while (c == ' ')
  1768.         c = readchar (timeout);
  1769.       if ((c == '0') && ((c = readchar (timeout)) == 'x'))
  1770.         ;
  1771.       else
  1772.         monitor_error ("monitor_read_memory_single",
  1773.                        "bad response from monitor",
  1774.                        memaddr, 0, NULL, 0);
  1775.     }

  1777.   {
  1778.     int i;

  1780.     for (i = 0; i < len * 2; i++)
  1781.       {
  1782.         int c;

  1784.         while (1)
  1785.           {
  1786.             c = readchar (timeout);
  1787.             if (isxdigit (c))
  1788.               break;
  1789.             if (c == ' ')
  1790.               continue;

  1792.             monitor_error ("monitor_read_memory_single",
  1793.                            "bad response from monitor",
  1794.                            memaddr, i, membuf, 0);
  1795.           }
  1796.       membuf[i] = c;
  1797.     }
  1798.     membuf[i] = '\000';                /* Terminate the number.  */
  1799.   }

  1801. /* If TERM is present, we wait for that to show up.  Also, (if TERM is
  1802.    present), we will send TERM_CMD if that is present.  In any case, we collect
  1803.    all of the output into buf, and then wait for the normal prompt.  */

  1805.   if (current_monitor->getmem.term)
  1806.     {
  1807.       monitor_expect (current_monitor->getmem.term, NULL, 0); /* Get
  1808.                                                                  response.  */

  1810.       if (current_monitor->getmem.term_cmd)
  1811.         {
  1812.           monitor_printf (current_monitor->getmem.term_cmd);
  1813.           monitor_expect_prompt (NULL, 0);
  1814.         }
  1815.     }
  1816.   else
  1817.     monitor_expect_prompt (NULL, 0);        /* Get response.  */

  1819.   p = membuf;
  1820.   val = strtoul (membuf, &p, 16);

  1822.   if (val == 0 && membuf == p)
  1823.     monitor_error ("monitor_read_memory_single",
  1824.                    "bad value from monitor",
  1825.                    memaddr, 0, membuf, 0);

  1827.   /* supply register stores in target byte order, so swap here.  */

  1829.   store_unsigned_integer (myaddr, len, byte_order, val);

  1831.   return len;
  1832. }

  1834. /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's
  1835.    memory at MEMADDR.  Returns length moved.  Currently, we do no more
  1836.    than 16 bytes at a time.  */

  1838. static int
  1839. ‌monitor_read_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len)
  1840. {
  1841.   unsigned int val;
  1842.   char buf[512];
  1843.   char *p, *p1;
  1844.   int resp_len;
  1845.   int i;
  1846.   CORE_ADDR dumpaddr;

  1848.   if (len <= 0)
  1849.     {
  1850.       monitor_debug ("Zero length call to monitor_read_memory\n");
  1851.       return 0;
  1852.     }

  1854.   monitor_debug ("MON read block ta(%s) ha(%s) %d\n",
  1855.                  paddress (target_gdbarch (), memaddr),
  1856.                  host_address_to_string (myaddr), len);

  1858.   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
  1859.     memaddr = gdbarch_addr_bits_remove (target_gdbarch (), memaddr);

  1861.   if (current_monitor->flags & MO_GETMEM_READ_SINGLE)
  1862.     return monitor_read_memory_single (memaddr, myaddr, len);

  1864.   len = min (len, 16);

  1866.   /* Some dumpers align the first data with the preceding 16
  1867.      byte boundary.  Some print blanks and start at the
  1868.      requested boundary.  EXACT_DUMPADDR  */

  1870.   dumpaddr = (current_monitor->flags & MO_EXACT_DUMPADDR)
  1871.     ? memaddr : memaddr & ~0x0f;

  1873.   /* See if xfer would cross a 16 byte boundary.  If so, clip it.  */
  1874.   if (((memaddr ^ (memaddr + len - 1)) & ~0xf) != 0)
  1875.     len = ((memaddr + len) & ~0xf) - memaddr;

  1877.   /* Send the memory examine command.  */

  1879.   if (current_monitor->flags & MO_GETMEM_NEEDS_RANGE)
  1880.     monitor_printf (current_monitor->getmem.cmdb, memaddr, memaddr + len);
  1881.   else if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
  1882.     monitor_printf (current_monitor->getmem.cmdb, dumpaddr);
  1883.   else
  1884.     monitor_printf (current_monitor->getmem.cmdb, memaddr, len);

  1886.   /* If TERM is present, we wait for that to show up.  Also, (if TERM
  1887.      is present), we will send TERM_CMD if that is present.  In any
  1888.      case, we collect all of the output into buf, and then wait for
  1889.      the normal prompt.  */

  1891.   if (current_monitor->getmem.term)
  1892.     {
  1893.       resp_len = monitor_expect (current_monitor->getmem.term,
  1894.                                  buf, sizeof buf);        /* Get response.  */

  1896.       if (resp_len <= 0)
  1897.         monitor_error ("monitor_read_memory",
  1898.                        "excessive response from monitor",
  1899.                        memaddr, resp_len, buf, 0);

  1901.       if (current_monitor->getmem.term_cmd)
  1902.         {
  1903.           serial_write (monitor_desc, current_monitor->getmem.term_cmd,
  1904.                         strlen (current_monitor->getmem.term_cmd));
  1905.           monitor_expect_prompt (NULL, 0);
  1906.         }
  1907.     }
  1908.   else
  1909.     resp_len = monitor_expect_prompt (buf, sizeof buf);         /* Get response.  */

  1911.   p = buf;

  1913.   /* If RESP_DELIM is specified, we search for that as a leading
  1914.      delimiter for the values.  Otherwise, we just start searching
  1915.      from the start of the buf.  */

  1917.   if (current_monitor->getmem.resp_delim)
  1918.     {
  1919.       int retval, tmp;
  1920.       struct re_registers resp_strings;

  1922.       monitor_debug ("MON getmem.resp_delim %s\n",
  1923.                      current_monitor->getmem.resp_delim);

  1925.       memset (&resp_strings, 0, sizeof (struct re_registers));
  1926.       tmp = strlen (p);
  1927.       retval = re_search (&getmem_resp_delim_pattern, p, tmp, 0, tmp,
  1928.                           &resp_strings);

  1930.       if (retval < 0)
  1931.         monitor_error ("monitor_read_memory",
  1932.                        "bad response from monitor",
  1933.                        memaddr, resp_len, buf, 0);

  1935.       p += resp_strings.end[0];
  1936. #if 0
  1937.       p = strstr (p, current_monitor->getmem.resp_delim);
  1938.       if (!p)
  1939.         monitor_error ("monitor_read_memory",
  1940.                        "bad response from monitor",
  1941.                        memaddr, resp_len, buf, 0);
  1942.       p += strlen (current_monitor->getmem.resp_delim);
  1943. #endif
  1944.     }
  1945.   monitor_debug ("MON scanning  %d ,%s '%s'\n", len,
  1946.                  host_address_to_string (p), p);
  1947.   if (current_monitor->flags & MO_GETMEM_16_BOUNDARY)
  1948.     {
  1949.       char c;
  1950.       int fetched = 0;
  1951.       i = len;
  1952.       c = *p;


  1955.       while (!(c == '\000' || c == '\n' || c == '\r') && i > 0)
  1956.         {
  1957.           if (isxdigit (c))
  1958.             {
  1959.               if ((dumpaddr >= memaddr) && (i > 0))
  1960.                 {
  1961.                   val = fromhex (c) * 16 + fromhex (*(p + 1));
  1962.                   *myaddr++ = val;
  1963.                   if (monitor_debug_p || remote_debug)
  1964.                     fprintf_unfiltered (gdb_stdlog, "[%02x]", val);
  1965.                   --i;
  1966.                   fetched++;
  1967.                 }
  1968.               ++dumpaddr;
  1969.               ++p;
  1970.             }
  1971.           ++p;                        /* Skip a blank or other non hex char.  */
  1972.           c = *p;
  1973.         }
  1974.       if (fetched == 0)
  1975.         error (_("Failed to read via monitor"));
  1976.       if (monitor_debug_p || remote_debug)
  1977.         fprintf_unfiltered (gdb_stdlog, "\n");
  1978.       return fetched;                /* Return the number of bytes actually
  1979.                                    read.  */
  1980.     }
  1981.   monitor_debug ("MON scanning bytes\n");

  1983.   for (i = len; i > 0; i--)
  1984.     {
  1985.       /* Skip non-hex chars, but bomb on end of string and newlines.  */

  1987.       while (1)
  1988.         {
  1989.           if (isxdigit (*p))
  1990.             break;

  1992.           if (*p == '\000' || *p == '\n' || *p == '\r')
  1993.             monitor_error ("monitor_read_memory",
  1994.                            "badly terminated response from monitor",
  1995.                            memaddr, resp_len, buf, 0);
  1996.           p++;
  1997.         }

  1999.       val = strtoul (p, &p1, 16);

  2001.       if (val == 0 && p == p1)
  2002.         monitor_error ("monitor_read_memory",
  2003.                        "bad value from monitor",
  2004.                        memaddr, resp_len, buf, 0);

  2006.       *myaddr++ = val;

  2008.       if (i == 1)
  2009.         break;

  2011.       p = p1;
  2012.     }

  2014.   return len;
  2015. }

  2017. /* Helper for monitor_xfer_partial that handles memory transfers.
  2018.    Arguments are like target_xfer_partial.  */

  2020. static enum target_xfer_status
  2021. ‌monitor_xfer_memory (gdb_byte *readbuf, const gdb_byte *writebuf,
  2022.                      ULONGEST memaddr, ULONGEST len, ULONGEST *xfered_len)
  2023. {
  2024.   int res;

  2026.   if (writebuf != NULL)
  2027.     {
  2028.       if (current_monitor->flags & MO_HAS_BLOCKWRITES)
  2029.         res = monitor_write_memory_block (memaddr, writebuf, len);
  2030.       else
  2031.         res = monitor_write_memory (memaddr, writebuf, len);
  2032.     }
  2033.   else
  2034.     {
  2035.       res = monitor_read_memory (memaddr, readbuf, len);
  2036.     }

  2038.   if (res <= 0)
  2039.     return TARGET_XFER_E_IO;
  2040.   else
  2041.     {
  2042.       *xfered_len = (ULONGEST) res;
  2043.       return TARGET_XFER_OK;
  2044.     }
  2045. }

  2047. /* Target to_xfer_partial implementation.  */

  2049. static enum target_xfer_status
  2050. ‌monitor_xfer_partial (struct target_ops *ops, enum target_object object,
  2051.                       const char *annex, gdb_byte *readbuf,
  2052.                       const gdb_byte *writebuf, ULONGEST offset, ULONGEST len,
  2053.                       ULONGEST *xfered_len)
  2054. {
  2055.   switch (object)
  2056.     {
  2057.     case TARGET_OBJECT_MEMORY:
  2058.       return monitor_xfer_memory (readbuf, writebuf, offset, len, xfered_len);

  2060.     default:
  2061.       return TARGET_XFER_E_IO;
  2062.     }
  2063. }

  2065. static void
  2066. ‌monitor_kill (struct target_ops *ops)
  2067. {
  2068.   return;                        /* Ignore attempts to kill target system.  */
  2069. }

  2071. /* All we actually do is set the PC to the start address of exec_bfd.  */

  2073. static void
  2074. ‌monitor_create_inferior (struct target_ops *ops, char *exec_file,
  2075.                          char *args, char **env, int from_tty)
  2076. {
  2077.   if (args && (*args != '\000'))
  2078.     error (_("Args are not supported by the monitor."));

  2080.   first_time = 1;
  2081.   clear_proceed_status (0);
  2082.   regcache_write_pc (get_current_regcache (),
  2083.                      bfd_get_start_address (exec_bfd));
  2084. }

  2086. /* Clean up when a program exits.
  2087.    The program actually lives on in the remote processor's RAM, and may be
  2088.    run again without a download.  Don't leave it full of breakpoint
  2089.    instructions.  */

  2091. static void
  2092. ‌monitor_mourn_inferior (struct target_ops *ops)
  2093. {
  2094.   unpush_target (targ_ops);
  2095.   generic_mourn_inferior ();        /* Do all the proper things now.  */
  2096.   delete_thread_silent (monitor_ptid);
  2097. }

  2099. /* Tell the monitor to add a breakpoint.  */

  2101. static int
  2102. ‌monitor_insert_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
  2103.                            struct bp_target_info *bp_tgt)
  2104. {
  2105.   CORE_ADDR addr = bp_tgt->placed_address = bp_tgt->reqstd_address;
  2106.   int i;
  2107.   int bplen;

  2109.   monitor_debug ("MON inst bkpt %s\n", paddress (gdbarch, addr));
  2110.   if (current_monitor->set_break == NULL)
  2111.     error (_("No set_break defined for this monitor"));

  2113.   if (current_monitor->flags & MO_ADDR_BITS_REMOVE)
  2114.     addr = gdbarch_addr_bits_remove (gdbarch, addr);

  2116.   /* Determine appropriate breakpoint size for this address.  */
  2117.   gdbarch_breakpoint_from_pc (gdbarch, &addr, &bplen);
  2118.   bp_tgt->placed_address = addr;
  2119.   bp_tgt->placed_size = bplen;

  2121.   for (i = 0; i < current_monitor->num_breakpoints; i++)
  2122.     {
  2123.       if (breakaddr[i] == 0)
  2124.         {
  2125.           breakaddr[i] = addr;
  2126.           monitor_printf (current_monitor->set_break, addr);
  2127.           monitor_expect_prompt (NULL, 0);
  2128.           return 0;
  2129.         }
  2130.     }

  2132.   error (_("Too many breakpoints (> %d) for monitor."),
  2133.          current_monitor->num_breakpoints);
  2134. }

  2136. /* Tell the monitor to remove a breakpoint.  */

  2138. static int
  2139. ‌monitor_remove_breakpoint (struct target_ops *ops, struct gdbarch *gdbarch,
  2140.                            struct bp_target_info *bp_tgt)
  2141. {
  2142.   CORE_ADDR addr = bp_tgt->placed_address;
  2143.   int i;

  2145.   monitor_debug ("MON rmbkpt %s\n", paddress (gdbarch, addr));
  2146.   if (current_monitor->clr_break == NULL)
  2147.     error (_("No clr_break defined for this monitor"));

  2149.   for (i = 0; i < current_monitor->num_breakpoints; i++)
  2150.     {
  2151.       if (breakaddr[i] == addr)
  2152.         {
  2153.           breakaddr[i] = 0;
  2154.           /* Some monitors remove breakpoints based on the address.  */
  2155.           if (current_monitor->flags & MO_CLR_BREAK_USES_ADDR)
  2156.             monitor_printf (current_monitor->clr_break, addr);
  2157.           else if (current_monitor->flags & MO_CLR_BREAK_1_BASED)
  2158.             monitor_printf (current_monitor->clr_break, i + 1);
  2159.           else
  2160.             monitor_printf (current_monitor->clr_break, i);
  2161.           monitor_expect_prompt (NULL, 0);
  2162.           return 0;
  2163.         }
  2164.     }
  2165.   fprintf_unfiltered (gdb_stderr,
  2166.                       "Can't find breakpoint associated with %s\n",
  2167.                       paddress (gdbarch, addr));
  2168.   return 1;
  2169. }

  2171. /* monitor_wait_srec_ack -- wait for the target to send an acknowledgement for
  2172.    an S-record.  Return non-zero if the ACK is received properly.  */

  2174. static int
  2175. ‌monitor_wait_srec_ack (void)
  2176. {
  2177.   int ch;

  2179.   if (current_monitor->flags & MO_SREC_ACK_PLUS)
  2180.     {
  2181.       return (readchar (timeout) == '+');
  2182.     }
  2183.   else if (current_monitor->flags & MO_SREC_ACK_ROTATE)
  2184.     {
  2185.       /* Eat two backspaces, a "rotating" char (|/-\), and a space.  */
  2186.       if ((ch = readchar (1)) < 0)
  2187.         return 0;
  2188.       if ((ch = readchar (1)) < 0)
  2189.         return 0;
  2190.       if ((ch = readchar (1)) < 0)
  2191.         return 0;
  2192.       if ((ch = readchar (1)) < 0)
  2193.         return 0;
  2194.     }
  2195.   return 1;
  2196. }

  2198. /* monitor_load -- download a file.  */

  2200. static void
  2201. ‌monitor_load (struct target_ops *self, const char *args, int from_tty)
  2202. {
  2203.   CORE_ADDR load_offset = 0;
  2204.   char **argv;
  2205.   struct cleanup *old_cleanups;
  2206.   char *filename;

  2208.   monitor_debug ("MON load\n");

  2210.   if (args == NULL)
  2211.     error_no_arg (_("file to load"));

  2213.   argv = gdb_buildargv (args);
  2214.   old_cleanups = make_cleanup_freeargv (argv);

  2216.   filename = tilde_expand (argv[0]);
  2217.   make_cleanup (xfree, filename);

  2219.   /* Enable user to specify address for downloading as 2nd arg to load.  */
  2220.   if (argv[1] != NULL)
  2221.     {
  2222.       const char *endptr;

  2224.       load_offset = strtoulst (argv[1], &endptr, 0);

  2226.       /* If the last word was not a valid number then
  2227.          treat it as a file name with spaces in.  */
  2228.       if (argv[1] == endptr)
  2229.         error (_("Invalid download offset:%s."), argv[1]);

  2231.       if (argv[2] != NULL)
  2232.         error (_("Too many parameters."));
  2233.     }

  2235.   monitor_printf (current_monitor->load);
  2236.   if (current_monitor->loadresp)
  2237.     monitor_expect (current_monitor->loadresp, NULL, 0);

  2239.   load_srec (monitor_desc, filename, load_offset,
  2240.              32, SREC_ALL, hashmark,
  2241.              current_monitor->flags & MO_SREC_ACK ?
  2242.              monitor_wait_srec_ack : NULL);

  2244.   monitor_expect_prompt (NULL, 0);

  2246.   do_cleanups (old_cleanups);

  2248.   /* Finally, make the PC point at the start address.  */
  2249.   if (exec_bfd)
  2250.     regcache_write_pc (get_current_regcache (),
  2251.                        bfd_get_start_address (exec_bfd));

  2253.   /* There used to be code here which would clear inferior_ptid and
  2254.      call clear_symtab_users.  None of that should be necessary:
  2255.      monitor targets should behave like remote protocol targets, and
  2256.      since generic_load does none of those things, this function
  2257.      shouldn't either.

  2259.      Furthermore, clearing inferior_ptid is *incorrect*.  After doing
  2260.      a load, we still have a valid connection to the monitor, with a
  2261.      live processor state to fiddle with.  The user can type
  2262.      `continue' or `jump *start' and make the program run.  If they do
  2263.      these things, however, GDB will be talking to a running program
  2264.      while inferior_ptid is null_ptid; this makes things like
  2265.      reinit_frame_cache very confused.  */
  2266. }

  2268. static void
  2269. ‌monitor_stop (struct target_ops *self, ptid_t ptid)
  2270. {
  2271.   monitor_debug ("MON stop\n");
  2272.   if ((current_monitor->flags & MO_SEND_BREAK_ON_STOP) != 0)
  2273.     serial_send_break (monitor_desc);
  2274.   if (current_monitor->stop)
  2275.     monitor_printf_noecho (current_monitor->stop);
  2276. }

  2278. /* Put a COMMAND string out to MONITOR.  Output from MONITOR is placed
  2279.    in OUTPUT until the prompt is seen.  FIXME: We read the characters
  2280.    ourseleves here cause of a nasty echo.  */

  2282. static void
  2283. ‌monitor_rcmd (struct target_ops *self, const char *command,
  2284.               struct ui_file *outbuf)
  2285. {
  2286.   char *p;
  2287.   int resp_len;
  2288.   char buf[1000];

  2290.   if (monitor_desc == NULL)
  2291.     error (_("monitor target not open."));

  2293.   p = current_monitor->prompt;

  2295.   /* Send the command.  Note that if no args were supplied, then we're
  2296.      just sending the monitor a newline, which is sometimes useful.  */

  2298.   monitor_printf ("%s\r", (command ? command : ""));

  2300.   resp_len = monitor_expect_prompt (buf, sizeof buf);

  2302.   fputs_unfiltered (buf, outbuf);        /* Output the response.  */
  2303. }

  2305. /* Convert hex digit A to a number.  */

  2307. #if 0
  2308. static int
  2309. from_hex (int a)
  2310. {
  2311.   if (a >= '0' && a <= '9')
  2312.     return a - '0';
  2313.   if (a >= 'a' && a <= 'f')
  2314.     return a - 'a' + 10;
  2315.   if (a >= 'A' && a <= 'F')
  2316.     return a - 'A' + 10;

  2318.   error (_("Reply contains invalid hex digit 0x%x"), a);
  2319. }
  2320. #endif

  2322. char *
  2323. ‌monitor_get_dev_name (void)
  2324. {
  2325.   return dev_name;
  2326. }

  2328. /* Check to see if a thread is still alive.  */

  2330. static int
  2331. ‌monitor_thread_alive (struct target_ops *ops, ptid_t ptid)
  2332. {
  2333.   if (ptid_equal (ptid, monitor_ptid))
  2334.     /* The monitor's task is always alive.  */
  2335.     return 1;

  2337.   return 0;
  2338. }

  2340. /* Convert a thread ID to a string.  Returns the string in a static
  2341.    buffer.  */

  2343. static char *
  2344. ‌monitor_pid_to_str (struct target_ops *ops, ptid_t ptid)
  2345. {
  2346.   static char buf[64];

  2348.   if (ptid_equal (monitor_ptid, ptid))
  2349.     {
  2350.       xsnprintf (buf, sizeof buf, "Thread <main>");
  2351.       return buf;
  2352.     }

  2354.   return normal_pid_to_str (ptid);
  2355. }

  2357. ‌static struct target_ops monitor_ops;

  2359. static void
  2360. ‌init_base_monitor_ops (void)
  2361. {
  2362.   monitor_ops.to_close = monitor_close;
  2363.   monitor_ops.to_detach = monitor_detach;
  2364.   monitor_ops.to_resume = monitor_resume;
  2365.   monitor_ops.to_wait = monitor_wait;
  2366.   monitor_ops.to_fetch_registers = monitor_fetch_registers;
  2367.   monitor_ops.to_store_registers = monitor_store_registers;
  2368.   monitor_ops.to_prepare_to_store = monitor_prepare_to_store;
  2369.   monitor_ops.to_xfer_partial = monitor_xfer_partial;
  2370.   monitor_ops.to_files_info = monitor_files_info;
  2371.   monitor_ops.to_insert_breakpoint = monitor_insert_breakpoint;
  2372.   monitor_ops.to_remove_breakpoint = monitor_remove_breakpoint;
  2373.   monitor_ops.to_kill = monitor_kill;
  2374.   monitor_ops.to_load = monitor_load;
  2375.   monitor_ops.to_create_inferior = monitor_create_inferior;
  2376.   monitor_ops.to_mourn_inferior = monitor_mourn_inferior;
  2377.   monitor_ops.to_stop = monitor_stop;
  2378.   monitor_ops.to_rcmd = monitor_rcmd;
  2379.   monitor_ops.to_log_command = serial_log_command;
  2380.   monitor_ops.to_thread_alive = monitor_thread_alive;
  2381.   monitor_ops.to_pid_to_str = monitor_pid_to_str;
  2382.   monitor_ops.to_stratum = process_stratum;
  2383.   monitor_ops.to_has_all_memory = default_child_has_all_memory;
  2384.   monitor_ops.to_has_memory = default_child_has_memory;
  2385.   monitor_ops.to_has_stack = default_child_has_stack;
  2386.   monitor_ops.to_has_registers = default_child_has_registers;
  2387.   monitor_ops.to_has_execution = default_child_has_execution;
  2388.   monitor_ops.to_magic = OPS_MAGIC;
  2389. }                                /* init_base_monitor_ops */

  2391. /* Init the target_ops structure pointed at by OPS.  */

  2393. void
  2394. ‌init_monitor_ops (struct target_ops *ops)
  2395. {
  2396.   if (monitor_ops.to_magic != OPS_MAGIC)
  2397.     init_base_monitor_ops ();

  2399.   memcpy (ops, &monitor_ops, sizeof monitor_ops);
  2400. }

  2402. /* Define additional commands that are usually only used by monitors.  */

  2404. /* -Wmissing-prototypes */
  2405. extern initialize_file_ftype _initialize_remote_monitors;

  2407. void
  2408. ‌_initialize_remote_monitors (void)
  2409. {
  2410.   init_base_monitor_ops ();
  2411.   add_setshow_boolean_cmd ("hash", no_class, &hashmark, _("\
  2412. Set display of activity while downloading a file."), _("\
  2413. Show display of activity while downloading a file."), _("\
  2414. When enabled, a hashmark \'#\' is displayed."),
  2415.                            NULL,
  2416.                            NULL, /* FIXME: i18n: */
  2417.                            &setlist, &showlist);

  2419.   add_setshow_zuinteger_cmd ("monitor", no_class, &monitor_debug_p, _("\
  2420. Set debugging of remote monitor communication."), _("\
  2421. Show debugging of remote monitor communication."), _("\
  2422. When enabled, communication between GDB and the remote monitor\n\
  2423. is displayed."),
  2424.                              NULL,
  2425.                              NULL, /* FIXME: i18n: */
  2426.                              &setdebuglist, &showdebuglist);

  2428.   /* Yes, 42000 is arbitrary.  The only sense out of it, is that it
  2429.      isn't 0.  */
  2430.   monitor_ptid = ptid_build (42000, 0, 42000);
  2431. }