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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [monitor.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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