OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [monitor.c] - Blame information for rev 280

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.