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

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [gdb/] [monitor.c] - Blame information for rev 842

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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