OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [remote-mips.c] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
/* Remote debugging interface for MIPS remote debugging protocol.
2
 
3
   Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
4
   2003, 2004, 2006, 2007, 2008 Free Software Foundation, Inc.
5
 
6
   Contributed by Cygnus Support.  Written by Ian Lance Taylor
7
   <ian@cygnus.com>.
8
 
9
   This file is part of GDB.
10
 
11
   This program is free software; you can redistribute it and/or modify
12
   it under the terms of the GNU General Public License as published by
13
   the Free Software Foundation; either version 3 of the License, or
14
   (at your option) any later version.
15
 
16
   This program is distributed in the hope that it will be useful,
17
   but WITHOUT ANY WARRANTY; without even the implied warranty of
18
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19
   GNU General Public License for more details.
20
 
21
   You should have received a copy of the GNU General Public License
22
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
23
 
24
#include "defs.h"
25
#include "inferior.h"
26
#include "bfd.h"
27
#include "symfile.h"
28
#include "gdbcmd.h"
29
#include "gdbcore.h"
30
#include "serial.h"
31
#include "target.h"
32
#include "exceptions.h"
33
#include "gdb_string.h"
34
#include "gdb_stat.h"
35
#include "regcache.h"
36
#include <ctype.h>
37
#include "mips-tdep.h"
38
 
39
 
40
/* Breakpoint types.  Values 0, 1, and 2 must agree with the watch
41
   types passed by breakpoint.c to target_insert_watchpoint.
42
   Value 3 is our own invention, and is used for ordinary instruction
43
   breakpoints.  Value 4 is used to mark an unused watchpoint in tables.  */
44
enum break_type
45
  {
46
    BREAK_WRITE,                /* 0 */
47
    BREAK_READ,                 /* 1 */
48
    BREAK_ACCESS,               /* 2 */
49
    BREAK_FETCH,                /* 3 */
50
    BREAK_UNUSED                /* 4 */
51
  };
52
 
53
/* Prototypes for local functions.  */
54
 
55
static int mips_readchar (int timeout);
56
 
57
static int mips_receive_header (unsigned char *hdr, int *pgarbage,
58
                                int ch, int timeout);
59
 
60
static int mips_receive_trailer (unsigned char *trlr, int *pgarbage,
61
                                 int *pch, int timeout);
62
 
63
static int mips_cksum (const unsigned char *hdr,
64
                       const unsigned char *data, int len);
65
 
66
static void mips_send_packet (const char *s, int get_ack);
67
 
68
static void mips_send_command (const char *cmd, int prompt);
69
 
70
static int mips_receive_packet (char *buff, int throw_error, int timeout);
71
 
72
static ULONGEST mips_request (int cmd, ULONGEST addr, ULONGEST data,
73
                              int *perr, int timeout, char *buff);
74
 
75
static void mips_initialize (void);
76
 
77
static void mips_open (char *name, int from_tty);
78
 
79
static void pmon_open (char *name, int from_tty);
80
 
81
static void ddb_open (char *name, int from_tty);
82
 
83
static void lsi_open (char *name, int from_tty);
84
 
85
static void mips_close (int quitting);
86
 
87
static void mips_detach (char *args, int from_tty);
88
 
89
static void mips_resume (ptid_t ptid, int step,
90
                         enum target_signal siggnal);
91
 
92
static ptid_t mips_wait (ptid_t ptid,
93
                               struct target_waitstatus *status);
94
 
95
static int mips_map_regno (int regno);
96
 
97
static void mips_fetch_registers (struct regcache *regcache, int regno);
98
 
99
static void mips_prepare_to_store (struct regcache *regcache);
100
 
101
static void mips_store_registers (struct regcache *regcache, int regno);
102
 
103
static unsigned int mips_fetch_word (CORE_ADDR addr);
104
 
105
static int mips_store_word (CORE_ADDR addr, unsigned int value,
106
                            char *old_contents);
107
 
108
static int mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len,
109
                             int write,
110
                             struct mem_attrib *attrib,
111
                             struct target_ops *target);
112
 
113
static void mips_files_info (struct target_ops *ignore);
114
 
115
static void mips_mourn_inferior (void);
116
 
117
static int pmon_makeb64 (unsigned long v, char *p, int n, int *chksum);
118
 
119
static int pmon_zeroset (int recsize, char **buff, int *amount,
120
                         unsigned int *chksum);
121
 
122
static int pmon_checkset (int recsize, char **buff, int *value);
123
 
124
static void pmon_make_fastrec (char **outbuf, unsigned char *inbuf,
125
                               int *inptr, int inamount, int *recsize,
126
                               unsigned int *csum, unsigned int *zerofill);
127
 
128
static int pmon_check_ack (char *mesg);
129
 
130
static void pmon_start_download (void);
131
 
132
static void pmon_end_download (int final, int bintotal);
133
 
134
static void pmon_download (char *buffer, int length);
135
 
136
static void pmon_load_fast (char *file);
137
 
138
static void mips_load (char *file, int from_tty);
139
 
140
static int mips_make_srec (char *buffer, int type, CORE_ADDR memaddr,
141
                           unsigned char *myaddr, int len);
142
 
143
static int mips_set_breakpoint (CORE_ADDR addr, int len, enum break_type type);
144
 
145
static int mips_clear_breakpoint (CORE_ADDR addr, int len,
146
                                  enum break_type type);
147
 
148
static int mips_common_breakpoint (int set, CORE_ADDR addr, int len,
149
                                   enum break_type type);
150
 
151
/* Forward declarations.  */
152
extern struct target_ops mips_ops;
153
extern struct target_ops pmon_ops;
154
extern struct target_ops ddb_ops;
155
/* *INDENT-OFF* */
156
/* The MIPS remote debugging interface is built on top of a simple
157
   packet protocol.  Each packet is organized as follows:
158
 
159
   SYN  The first character is always a SYN (ASCII 026, or ^V).  SYN
160
   may not appear anywhere else in the packet.  Any time a SYN is
161
   seen, a new packet should be assumed to have begun.
162
 
163
   TYPE_LEN
164
   This byte contains the upper five bits of the logical length
165
   of the data section, plus a single bit indicating whether this
166
   is a data packet or an acknowledgement.  The documentation
167
   indicates that this bit is 1 for a data packet, but the actual
168
   board uses 1 for an acknowledgement.  The value of the byte is
169
   0x40 + (ack ? 0x20 : 0) + (len >> 6)
170
   (we always have 0 <= len < 1024).  Acknowledgement packets do
171
   not carry data, and must have a data length of 0.
172
 
173
   LEN1 This byte contains the lower six bits of the logical length of
174
   the data section.  The value is
175
   0x40 + (len & 0x3f)
176
 
177
   SEQ  This byte contains the six bit sequence number of the packet.
178
   The value is
179
   0x40 + seq
180
   An acknowlegment packet contains the sequence number of the
181
   packet being acknowledged plus 1 modulo 64.  Data packets are
182
   transmitted in sequence.  There may only be one outstanding
183
   unacknowledged data packet at a time.  The sequence numbers
184
   are independent in each direction.  If an acknowledgement for
185
   the previous packet is received (i.e., an acknowledgement with
186
   the sequence number of the packet just sent) the packet just
187
   sent should be retransmitted.  If no acknowledgement is
188
   received within a timeout period, the packet should be
189
   retransmitted.  This has an unfortunate failure condition on a
190
   high-latency line, as a delayed acknowledgement may lead to an
191
   endless series of duplicate packets.
192
 
193
   DATA The actual data bytes follow.  The following characters are
194
   escaped inline with DLE (ASCII 020, or ^P):
195
   SYN (026)    DLE S
196
   DLE (020)    DLE D
197
   ^C  (003)    DLE C
198
   ^S  (023)    DLE s
199
   ^Q  (021)    DLE q
200
   The additional DLE characters are not counted in the logical
201
   length stored in the TYPE_LEN and LEN1 bytes.
202
 
203
   CSUM1
204
   CSUM2
205
   CSUM3
206
   These bytes contain an 18 bit checksum of the complete
207
   contents of the packet excluding the SEQ byte and the
208
   CSUM[123] bytes.  The checksum is simply the twos complement
209
   addition of all the bytes treated as unsigned characters.  The
210
   values of the checksum bytes are:
211
   CSUM1: 0x40 + ((cksum >> 12) & 0x3f)
212
   CSUM2: 0x40 + ((cksum >> 6) & 0x3f)
213
   CSUM3: 0x40 + (cksum & 0x3f)
214
 
215
   It happens that the MIPS remote debugging protocol always
216
   communicates with ASCII strings.  Because of this, this
217
   implementation doesn't bother to handle the DLE quoting mechanism,
218
   since it will never be required.  */
219
/* *INDENT-ON* */
220
 
221
 
222
/* The SYN character which starts each packet.  */
223
#define SYN '\026'
224
 
225
/* The 0x40 used to offset each packet (this value ensures that all of
226
   the header and trailer bytes, other than SYN, are printable ASCII
227
   characters).  */
228
#define HDR_OFFSET 0x40
229
 
230
/* The indices of the bytes in the packet header.  */
231
#define HDR_INDX_SYN 0
232
#define HDR_INDX_TYPE_LEN 1
233
#define HDR_INDX_LEN1 2
234
#define HDR_INDX_SEQ 3
235
#define HDR_LENGTH 4
236
 
237
/* The data/ack bit in the TYPE_LEN header byte.  */
238
#define TYPE_LEN_DA_BIT 0x20
239
#define TYPE_LEN_DATA 0
240
#define TYPE_LEN_ACK TYPE_LEN_DA_BIT
241
 
242
/* How to compute the header bytes.  */
243
#define HDR_SET_SYN(data, len, seq) (SYN)
244
#define HDR_SET_TYPE_LEN(data, len, seq) \
245
  (HDR_OFFSET \
246
   + ((data) ? TYPE_LEN_DATA : TYPE_LEN_ACK) \
247
   + (((len) >> 6) & 0x1f))
248
#define HDR_SET_LEN1(data, len, seq) (HDR_OFFSET + ((len) & 0x3f))
249
#define HDR_SET_SEQ(data, len, seq) (HDR_OFFSET + (seq))
250
 
251
/* Check that a header byte is reasonable.  */
252
#define HDR_CHECK(ch) (((ch) & HDR_OFFSET) == HDR_OFFSET)
253
 
254
/* Get data from the header.  These macros evaluate their argument
255
   multiple times.  */
256
#define HDR_IS_DATA(hdr) \
257
  (((hdr)[HDR_INDX_TYPE_LEN] & TYPE_LEN_DA_BIT) == TYPE_LEN_DATA)
258
#define HDR_GET_LEN(hdr) \
259
  ((((hdr)[HDR_INDX_TYPE_LEN] & 0x1f) << 6) + (((hdr)[HDR_INDX_LEN1] & 0x3f)))
260
#define HDR_GET_SEQ(hdr) ((unsigned int)(hdr)[HDR_INDX_SEQ] & 0x3f)
261
 
262
/* The maximum data length.  */
263
#define DATA_MAXLEN 1023
264
 
265
/* The trailer offset.  */
266
#define TRLR_OFFSET HDR_OFFSET
267
 
268
/* The indices of the bytes in the packet trailer.  */
269
#define TRLR_INDX_CSUM1 0
270
#define TRLR_INDX_CSUM2 1
271
#define TRLR_INDX_CSUM3 2
272
#define TRLR_LENGTH 3
273
 
274
/* How to compute the trailer bytes.  */
275
#define TRLR_SET_CSUM1(cksum) (TRLR_OFFSET + (((cksum) >> 12) & 0x3f))
276
#define TRLR_SET_CSUM2(cksum) (TRLR_OFFSET + (((cksum) >>  6) & 0x3f))
277
#define TRLR_SET_CSUM3(cksum) (TRLR_OFFSET + (((cksum)      ) & 0x3f))
278
 
279
/* Check that a trailer byte is reasonable.  */
280
#define TRLR_CHECK(ch) (((ch) & TRLR_OFFSET) == TRLR_OFFSET)
281
 
282
/* Get data from the trailer.  This evaluates its argument multiple
283
   times.  */
284
#define TRLR_GET_CKSUM(trlr) \
285
  ((((trlr)[TRLR_INDX_CSUM1] & 0x3f) << 12) \
286
   + (((trlr)[TRLR_INDX_CSUM2] & 0x3f) <<  6) \
287
   + ((trlr)[TRLR_INDX_CSUM3] & 0x3f))
288
 
289
/* The sequence number modulos.  */
290
#define SEQ_MODULOS (64)
291
 
292
/* PMON commands to load from the serial port or UDP socket.  */
293
#define LOAD_CMD        "load -b -s tty0\r"
294
#define LOAD_CMD_UDP    "load -b -s udp\r"
295
 
296
/* The target vectors for the four different remote MIPS targets.
297
   These are initialized with code in _initialize_remote_mips instead
298
   of static initializers, to make it easier to extend the target_ops
299
   vector later.  */
300
struct target_ops mips_ops, pmon_ops, ddb_ops, lsi_ops;
301
 
302
enum mips_monitor_type
303
  {
304
    /* IDT/SIM monitor being used: */
305
    MON_IDT,
306
    /* PMON monitor being used: */
307
    MON_PMON,                   /* 3.0.83 [COGENT,EB,FP,NET] Algorithmics Ltd. Nov  9 1995 17:19:50 */
308
    MON_DDB,                    /* 2.7.473 [DDBVR4300,EL,FP,NET] Risq Modular Systems,  Thu Jun 6 09:28:40 PDT 1996 */
309
    MON_LSI,                    /* 4.3.12 [EB,FP], LSI LOGIC Corp. Tue Feb 25 13:22:14 1997 */
310
    /* Last and unused value, for sizing vectors, etc. */
311
    MON_LAST
312
  };
313
static enum mips_monitor_type mips_monitor = MON_LAST;
314
 
315
/* The monitor prompt text.  If the user sets the PMON prompt
316
   to some new value, the GDB `set monitor-prompt' command must also
317
   be used to inform GDB about the expected prompt.  Otherwise, GDB
318
   will not be able to connect to PMON in mips_initialize().
319
   If the `set monitor-prompt' command is not used, the expected
320
   default prompt will be set according the target:
321
   target               prompt
322
   -----                -----
323
   pmon         PMON>
324
   ddb          NEC010>
325
   lsi          PMON>
326
 */
327
static char *mips_monitor_prompt;
328
 
329
/* Set to 1 if the target is open.  */
330
static int mips_is_open;
331
 
332
/* Currently active target description (if mips_is_open == 1) */
333
static struct target_ops *current_ops;
334
 
335
/* Set to 1 while the connection is being initialized.  */
336
static int mips_initializing;
337
 
338
/* Set to 1 while the connection is being brought down.  */
339
static int mips_exiting;
340
 
341
/* The next sequence number to send.  */
342
static unsigned int mips_send_seq;
343
 
344
/* The next sequence number we expect to receive.  */
345
static unsigned int mips_receive_seq;
346
 
347
/* The time to wait before retransmitting a packet, in seconds.  */
348
static int mips_retransmit_wait = 3;
349
 
350
/* The number of times to try retransmitting a packet before giving up.  */
351
static int mips_send_retries = 10;
352
 
353
/* The number of garbage characters to accept when looking for an
354
   SYN for the next packet.  */
355
static int mips_syn_garbage = 10;
356
 
357
/* The time to wait for a packet, in seconds.  */
358
static int mips_receive_wait = 5;
359
 
360
/* Set if we have sent a packet to the board but have not yet received
361
   a reply.  */
362
static int mips_need_reply = 0;
363
 
364
/* Handle used to access serial I/O stream.  */
365
static struct serial *mips_desc;
366
 
367
/* UDP handle used to download files to target.  */
368
static struct serial *udp_desc;
369
static int udp_in_use;
370
 
371
/* TFTP filename used to download files to DDB board, in the form
372
   host:filename.  */
373
static char *tftp_name;         /* host:filename */
374
static char *tftp_localname;    /* filename portion of above */
375
static int tftp_in_use;
376
static FILE *tftp_file;
377
 
378
/* Counts the number of times the user tried to interrupt the target (usually
379
   via ^C.  */
380
static int interrupt_count;
381
 
382
/* If non-zero, means that the target is running. */
383
static int mips_wait_flag = 0;
384
 
385
/* If non-zero, monitor supports breakpoint commands. */
386
static int monitor_supports_breakpoints = 0;
387
 
388
/* Data cache header.  */
389
 
390
#if 0                           /* not used (yet?) */
391
static DCACHE *mips_dcache;
392
#endif
393
 
394
/* Non-zero means that we've just hit a read or write watchpoint */
395
static int hit_watchpoint;
396
 
397
/* Table of breakpoints/watchpoints (used only on LSI PMON target).
398
   The table is indexed by a breakpoint number, which is an integer
399
   from 0 to 255 returned by the LSI PMON when a breakpoint is set.
400
 */
401
#define MAX_LSI_BREAKPOINTS 256
402
struct lsi_breakpoint_info
403
  {
404
    enum break_type type;       /* type of breakpoint */
405
    CORE_ADDR addr;             /* address of breakpoint */
406
    int len;                    /* length of region being watched */
407
    unsigned long value;        /* value to watch */
408
  }
409
lsi_breakpoints[MAX_LSI_BREAKPOINTS];
410
 
411
/* Error/warning codes returned by LSI PMON for breakpoint commands.
412
   Warning values may be ORed together; error values may not.  */
413
#define W_WARN  0x100           /* This bit is set if the error code is a warning */
414
#define W_MSK   0x101           /* warning: Range feature is supported via mask */
415
#define W_VAL   0x102           /* warning: Value check is not supported in hardware */
416
#define W_QAL   0x104           /* warning: Requested qualifiers are not supported in hardware */
417
 
418
#define E_ERR   0x200           /* This bit is set if the error code is an error */
419
#define E_BPT   0x200           /* error: No such breakpoint number */
420
#define E_RGE   0x201           /* error: Range is not supported */
421
#define E_QAL   0x202           /* error: The requested qualifiers can not be used */
422
#define E_OUT   0x203           /* error: Out of hardware resources */
423
#define E_NON   0x204           /* error: Hardware breakpoint not supported */
424
 
425
struct lsi_error
426
  {
427
    int code;                   /* error code */
428
    char *string;               /* string associated with this code */
429
  };
430
 
431
struct lsi_error lsi_warning_table[] =
432
{
433
  {W_MSK, "Range feature is supported via mask"},
434
  {W_VAL, "Value check is not supported in hardware"},
435
  {W_QAL, "Requested qualifiers are not supported in hardware"},
436
  {0, NULL}
437
};
438
 
439
struct lsi_error lsi_error_table[] =
440
{
441
  {E_BPT, "No such breakpoint number"},
442
  {E_RGE, "Range is not supported"},
443
  {E_QAL, "The requested qualifiers can not be used"},
444
  {E_OUT, "Out of hardware resources"},
445
  {E_NON, "Hardware breakpoint not supported"},
446
  {0, NULL}
447
};
448
 
449
/* Set to 1 with the 'set monitor-warnings' command to enable printing
450
   of warnings returned by PMON when hardware breakpoints are used.  */
451
static int monitor_warnings;
452
 
453
 
454
static void
455
close_ports (void)
456
{
457
  mips_is_open = 0;
458
  serial_close (mips_desc);
459
 
460
  if (udp_in_use)
461
    {
462
      serial_close (udp_desc);
463
      udp_in_use = 0;
464
    }
465
  tftp_in_use = 0;
466
}
467
 
468
/* Handle low-level error that we can't recover from.  Note that just
469
   error()ing out from target_wait or some such low-level place will cause
470
   all hell to break loose--the rest of GDB will tend to get left in an
471
   inconsistent state.  */
472
 
473
static NORETURN void
474
mips_error (char *string,...)
475
{
476
  va_list args;
477
 
478
  va_start (args, string);
479
 
480
  target_terminal_ours ();
481
  wrap_here ("");               /* Force out any buffered output */
482
  gdb_flush (gdb_stdout);
483
  if (error_pre_print)
484
    fputs_filtered (error_pre_print, gdb_stderr);
485
  vfprintf_filtered (gdb_stderr, string, args);
486
  fprintf_filtered (gdb_stderr, "\n");
487
  va_end (args);
488
  gdb_flush (gdb_stderr);
489
 
490
  /* Clean up in such a way that mips_close won't try to talk to the
491
     board (it almost surely won't work since we weren't able to talk to
492
     it).  */
493
  close_ports ();
494
 
495
  printf_unfiltered ("Ending remote MIPS debugging.\n");
496
  target_mourn_inferior ();
497
 
498
  deprecated_throw_reason (RETURN_ERROR);
499
}
500
 
501
/* putc_readable - print a character, displaying non-printable chars in
502
   ^x notation or in hex.  */
503
 
504
static void
505
fputc_readable (int ch, struct ui_file *file)
506
{
507
  if (ch == '\n')
508
    fputc_unfiltered ('\n', file);
509
  else if (ch == '\r')
510
    fprintf_unfiltered (file, "\\r");
511
  else if (ch < 0x20)           /* ASCII control character */
512
    fprintf_unfiltered (file, "^%c", ch + '@');
513
  else if (ch >= 0x7f)          /* non-ASCII characters (rubout or greater) */
514
    fprintf_unfiltered (file, "[%02x]", ch & 0xff);
515
  else
516
    fputc_unfiltered (ch, file);
517
}
518
 
519
 
520
/* puts_readable - print a string, displaying non-printable chars in
521
   ^x notation or in hex.  */
522
 
523
static void
524
fputs_readable (const char *string, struct ui_file *file)
525
{
526
  int c;
527
 
528
  while ((c = *string++) != '\0')
529
    fputc_readable (c, file);
530
}
531
 
532
 
533
/* Wait until STRING shows up in mips_desc.  Returns 1 if successful, else 0 if
534
   timed out.  TIMEOUT specifies timeout value in seconds.
535
 */
536
 
537
static int
538
mips_expect_timeout (const char *string, int timeout)
539
{
540
  const char *p = string;
541
 
542
  if (remote_debug)
543
    {
544
      fprintf_unfiltered (gdb_stdlog, "Expected \"");
545
      fputs_readable (string, gdb_stdlog);
546
      fprintf_unfiltered (gdb_stdlog, "\", got \"");
547
    }
548
 
549
  immediate_quit++;
550
  while (1)
551
    {
552
      int c;
553
 
554
      /* Must use serial_readchar() here cuz mips_readchar would get
555
         confused if we were waiting for the mips_monitor_prompt... */
556
 
557
      c = serial_readchar (mips_desc, timeout);
558
 
559
      if (c == SERIAL_TIMEOUT)
560
        {
561
          if (remote_debug)
562
            fprintf_unfiltered (gdb_stdlog, "\": FAIL\n");
563
          return 0;
564
        }
565
 
566
      if (remote_debug)
567
        fputc_readable (c, gdb_stdlog);
568
 
569
      if (c == *p++)
570
        {
571
          if (*p == '\0')
572
            {
573
              immediate_quit--;
574
              if (remote_debug)
575
                fprintf_unfiltered (gdb_stdlog, "\": OK\n");
576
              return 1;
577
            }
578
        }
579
      else
580
        {
581
          p = string;
582
          if (c == *p)
583
            p++;
584
        }
585
    }
586
}
587
 
588
/* Wait until STRING shows up in mips_desc.  Returns 1 if successful, else 0 if
589
   timed out.  The timeout value is hard-coded to 2 seconds.  Use
590
   mips_expect_timeout if a different timeout value is needed.
591
 */
592
 
593
static int
594
mips_expect (const char *string)
595
{
596
  return mips_expect_timeout (string, remote_timeout);
597
}
598
 
599
/* Read a character from the remote, aborting on error.  Returns
600
   SERIAL_TIMEOUT on timeout (since that's what serial_readchar()
601
   returns).  FIXME: If we see the string mips_monitor_prompt from the
602
   board, then we are debugging on the main console port, and we have
603
   somehow dropped out of remote debugging mode.  In this case, we
604
   automatically go back in to remote debugging mode.  This is a hack,
605
   put in because I can't find any way for a program running on the
606
   remote board to terminate without also ending remote debugging
607
   mode.  I assume users won't have any trouble with this; for one
608
   thing, the IDT documentation generally assumes that the remote
609
   debugging port is not the console port.  This is, however, very
610
   convenient for DejaGnu when you only have one connected serial
611
   port.  */
612
 
613
static int
614
mips_readchar (int timeout)
615
{
616
  int ch;
617
  static int state = 0;
618
  int mips_monitor_prompt_len = strlen (mips_monitor_prompt);
619
 
620
  {
621
    int i;
622
 
623
    i = timeout;
624
    if (i == -1 && watchdog > 0)
625
      i = watchdog;
626
  }
627
 
628
  if (state == mips_monitor_prompt_len)
629
    timeout = 1;
630
  ch = serial_readchar (mips_desc, timeout);
631
 
632
  if (ch == SERIAL_TIMEOUT && timeout == -1)    /* Watchdog went off */
633
    {
634
      target_mourn_inferior ();
635
      error ("Watchdog has expired.  Target detached.\n");
636
    }
637
 
638
  if (ch == SERIAL_EOF)
639
    mips_error ("End of file from remote");
640
  if (ch == SERIAL_ERROR)
641
    mips_error ("Error reading from remote: %s", safe_strerror (errno));
642
  if (remote_debug > 1)
643
    {
644
      /* Don't use _filtered; we can't deal with a QUIT out of
645
         target_wait, and I think this might be called from there.  */
646
      if (ch != SERIAL_TIMEOUT)
647
        fprintf_unfiltered (gdb_stdlog, "Read '%c' %d 0x%x\n", ch, ch, ch);
648
      else
649
        fprintf_unfiltered (gdb_stdlog, "Timed out in read\n");
650
    }
651
 
652
  /* If we have seen mips_monitor_prompt and we either time out, or
653
     we see a @ (which was echoed from a packet we sent), reset the
654
     board as described above.  The first character in a packet after
655
     the SYN (which is not echoed) is always an @ unless the packet is
656
     more than 64 characters long, which ours never are.  */
657
  if ((ch == SERIAL_TIMEOUT || ch == '@')
658
      && state == mips_monitor_prompt_len
659
      && !mips_initializing
660
      && !mips_exiting)
661
    {
662
      if (remote_debug > 0)
663
        /* Don't use _filtered; we can't deal with a QUIT out of
664
           target_wait, and I think this might be called from there.  */
665
        fprintf_unfiltered (gdb_stdlog, "Reinitializing MIPS debugging mode\n");
666
 
667
      mips_need_reply = 0;
668
      mips_initialize ();
669
 
670
      state = 0;
671
 
672
      /* At this point, about the only thing we can do is abort the command
673
         in progress and get back to command level as quickly as possible. */
674
 
675
      error ("Remote board reset, debug protocol re-initialized.");
676
    }
677
 
678
  if (ch == mips_monitor_prompt[state])
679
    ++state;
680
  else
681
    state = 0;
682
 
683
  return ch;
684
}
685
 
686
/* Get a packet header, putting the data in the supplied buffer.
687
   PGARBAGE is a pointer to the number of garbage characters received
688
   so far.  CH is the last character received.  Returns 0 for success,
689
   or -1 for timeout.  */
690
 
691
static int
692
mips_receive_header (unsigned char *hdr, int *pgarbage, int ch, int timeout)
693
{
694
  int i;
695
 
696
  while (1)
697
    {
698
      /* Wait for a SYN.  mips_syn_garbage is intended to prevent
699
         sitting here indefinitely if the board sends us one garbage
700
         character per second.  ch may already have a value from the
701
         last time through the loop.  */
702
      while (ch != SYN)
703
        {
704
          ch = mips_readchar (timeout);
705
          if (ch == SERIAL_TIMEOUT)
706
            return -1;
707
          if (ch != SYN)
708
            {
709
              /* Printing the character here lets the user of gdb see
710
                 what the program is outputting, if the debugging is
711
                 being done on the console port.  Don't use _filtered:
712
                 we can't deal with a QUIT out of target_wait and
713
                 buffered target output confuses the user. */
714
              if (!mips_initializing || remote_debug > 0)
715
                {
716
                  if (isprint (ch) || isspace (ch))
717
                    {
718
                      fputc_unfiltered (ch, gdb_stdtarg);
719
                    }
720
                  else
721
                    {
722
                      fputc_readable (ch, gdb_stdtarg);
723
                    }
724
                  gdb_flush (gdb_stdtarg);
725
                }
726
 
727
              /* Only count unprintable characters. */
728
              if (! (isprint (ch) || isspace (ch)))
729
                (*pgarbage) += 1;
730
 
731
              if (mips_syn_garbage > 0
732
                  && *pgarbage > mips_syn_garbage)
733
                mips_error ("Debug protocol failure:  more than %d characters before a sync.",
734
                            mips_syn_garbage);
735
            }
736
        }
737
 
738
      /* Get the packet header following the SYN.  */
739
      for (i = 1; i < HDR_LENGTH; i++)
740
        {
741
          ch = mips_readchar (timeout);
742
          if (ch == SERIAL_TIMEOUT)
743
            return -1;
744
          /* Make sure this is a header byte.  */
745
          if (ch == SYN || !HDR_CHECK (ch))
746
            break;
747
 
748
          hdr[i] = ch;
749
        }
750
 
751
      /* If we got the complete header, we can return.  Otherwise we
752
         loop around and keep looking for SYN.  */
753
      if (i >= HDR_LENGTH)
754
        return 0;
755
    }
756
}
757
 
758
/* Get a packet header, putting the data in the supplied buffer.
759
   PGARBAGE is a pointer to the number of garbage characters received
760
   so far.  The last character read is returned in *PCH.  Returns 0
761
   for success, -1 for timeout, -2 for error.  */
762
 
763
static int
764
mips_receive_trailer (unsigned char *trlr, int *pgarbage, int *pch, int timeout)
765
{
766
  int i;
767
  int ch;
768
 
769
  for (i = 0; i < TRLR_LENGTH; i++)
770
    {
771
      ch = mips_readchar (timeout);
772
      *pch = ch;
773
      if (ch == SERIAL_TIMEOUT)
774
        return -1;
775
      if (!TRLR_CHECK (ch))
776
        return -2;
777
      trlr[i] = ch;
778
    }
779
  return 0;
780
}
781
 
782
/* Get the checksum of a packet.  HDR points to the packet header.
783
   DATA points to the packet data.  LEN is the length of DATA.  */
784
 
785
static int
786
mips_cksum (const unsigned char *hdr, const unsigned char *data, int len)
787
{
788
  const unsigned char *p;
789
  int c;
790
  int cksum;
791
 
792
  cksum = 0;
793
 
794
  /* The initial SYN is not included in the checksum.  */
795
  c = HDR_LENGTH - 1;
796
  p = hdr + 1;
797
  while (c-- != 0)
798
    cksum += *p++;
799
 
800
  c = len;
801
  p = data;
802
  while (c-- != 0)
803
    cksum += *p++;
804
 
805
  return cksum;
806
}
807
 
808
/* Send a packet containing the given ASCII string.  */
809
 
810
static void
811
mips_send_packet (const char *s, int get_ack)
812
{
813
  /* unsigned */ int len;
814
  unsigned char *packet;
815
  int cksum;
816
  int try;
817
 
818
  len = strlen (s);
819
  if (len > DATA_MAXLEN)
820
    mips_error ("MIPS protocol data packet too long: %s", s);
821
 
822
  packet = (unsigned char *) alloca (HDR_LENGTH + len + TRLR_LENGTH + 1);
823
 
824
  packet[HDR_INDX_SYN] = HDR_SET_SYN (1, len, mips_send_seq);
825
  packet[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (1, len, mips_send_seq);
826
  packet[HDR_INDX_LEN1] = HDR_SET_LEN1 (1, len, mips_send_seq);
827
  packet[HDR_INDX_SEQ] = HDR_SET_SEQ (1, len, mips_send_seq);
828
 
829
  memcpy (packet + HDR_LENGTH, s, len);
830
 
831
  cksum = mips_cksum (packet, packet + HDR_LENGTH, len);
832
  packet[HDR_LENGTH + len + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
833
  packet[HDR_LENGTH + len + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
834
  packet[HDR_LENGTH + len + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
835
 
836
  /* Increment the sequence number.  This will set mips_send_seq to
837
     the sequence number we expect in the acknowledgement.  */
838
  mips_send_seq = (mips_send_seq + 1) % SEQ_MODULOS;
839
 
840
  /* We can only have one outstanding data packet, so we just wait for
841
     the acknowledgement here.  Keep retransmitting the packet until
842
     we get one, or until we've tried too many times.  */
843
  for (try = 0; try < mips_send_retries; try++)
844
    {
845
      int garbage;
846
      int ch;
847
 
848
      if (remote_debug > 0)
849
        {
850
          /* Don't use _filtered; we can't deal with a QUIT out of
851
             target_wait, and I think this might be called from there.  */
852
          packet[HDR_LENGTH + len + TRLR_LENGTH] = '\0';
853
          fprintf_unfiltered (gdb_stdlog, "Writing \"%s\"\n", packet + 1);
854
        }
855
 
856
      if (serial_write (mips_desc, packet,
857
                        HDR_LENGTH + len + TRLR_LENGTH) != 0)
858
        mips_error ("write to target failed: %s", safe_strerror (errno));
859
 
860
      if (!get_ack)
861
        return;
862
 
863
      garbage = 0;
864
      ch = 0;
865
      while (1)
866
        {
867
          unsigned char hdr[HDR_LENGTH + 1];
868
          unsigned char trlr[TRLR_LENGTH + 1];
869
          int err;
870
          unsigned int seq;
871
 
872
          /* Get the packet header.  If we time out, resend the data
873
             packet.  */
874
          err = mips_receive_header (hdr, &garbage, ch, mips_retransmit_wait);
875
          if (err != 0)
876
            break;
877
 
878
          ch = 0;
879
 
880
          /* If we get a data packet, assume it is a duplicate and
881
             ignore it.  FIXME: If the acknowledgement is lost, this
882
             data packet may be the packet the remote sends after the
883
             acknowledgement.  */
884
          if (HDR_IS_DATA (hdr))
885
            {
886
              int i;
887
 
888
              /* Ignore any errors raised whilst attempting to ignore
889
                 packet. */
890
 
891
              len = HDR_GET_LEN (hdr);
892
 
893
              for (i = 0; i < len; i++)
894
                {
895
                  int rch;
896
 
897
                  rch = mips_readchar (remote_timeout);
898
                  if (rch == SYN)
899
                    {
900
                      ch = SYN;
901
                      break;
902
                    }
903
                  if (rch == SERIAL_TIMEOUT)
904
                    break;
905
                  /* ignore the character */
906
                }
907
 
908
              if (i == len)
909
                (void) mips_receive_trailer (trlr, &garbage, &ch,
910
                                             remote_timeout);
911
 
912
              /* We don't bother checking the checksum, or providing an
913
                 ACK to the packet. */
914
              continue;
915
            }
916
 
917
          /* If the length is not 0, this is a garbled packet.  */
918
          if (HDR_GET_LEN (hdr) != 0)
919
            continue;
920
 
921
          /* Get the packet trailer.  */
922
          err = mips_receive_trailer (trlr, &garbage, &ch,
923
                                      mips_retransmit_wait);
924
 
925
          /* If we timed out, resend the data packet.  */
926
          if (err == -1)
927
            break;
928
 
929
          /* If we got a bad character, reread the header.  */
930
          if (err != 0)
931
            continue;
932
 
933
          /* If the checksum does not match the trailer checksum, this
934
             is a bad packet; ignore it.  */
935
          if (mips_cksum (hdr, (unsigned char *) NULL, 0)
936
              != TRLR_GET_CKSUM (trlr))
937
            continue;
938
 
939
          if (remote_debug > 0)
940
            {
941
              hdr[HDR_LENGTH] = '\0';
942
              trlr[TRLR_LENGTH] = '\0';
943
              /* Don't use _filtered; we can't deal with a QUIT out of
944
                 target_wait, and I think this might be called from there.  */
945
              fprintf_unfiltered (gdb_stdlog, "Got ack %d \"%s%s\"\n",
946
                                  HDR_GET_SEQ (hdr), hdr + 1, trlr);
947
            }
948
 
949
          /* If this ack is for the current packet, we're done.  */
950
          seq = HDR_GET_SEQ (hdr);
951
          if (seq == mips_send_seq)
952
            return;
953
 
954
          /* If this ack is for the last packet, resend the current
955
             packet.  */
956
          if ((seq + 1) % SEQ_MODULOS == mips_send_seq)
957
            break;
958
 
959
          /* Otherwise this is a bad ack; ignore it.  Increment the
960
             garbage count to ensure that we do not stay in this loop
961
             forever.  */
962
          ++garbage;
963
        }
964
    }
965
 
966
  mips_error ("Remote did not acknowledge packet");
967
}
968
 
969
/* Receive and acknowledge a packet, returning the data in BUFF (which
970
   should be DATA_MAXLEN + 1 bytes).  The protocol documentation
971
   implies that only the sender retransmits packets, so this code just
972
   waits silently for a packet.  It returns the length of the received
973
   packet.  If THROW_ERROR is nonzero, call error() on errors.  If not,
974
   don't print an error message and return -1.  */
975
 
976
static int
977
mips_receive_packet (char *buff, int throw_error, int timeout)
978
{
979
  int ch;
980
  int garbage;
981
  int len;
982
  unsigned char ack[HDR_LENGTH + TRLR_LENGTH + 1];
983
  int cksum;
984
 
985
  ch = 0;
986
  garbage = 0;
987
  while (1)
988
    {
989
      unsigned char hdr[HDR_LENGTH];
990
      unsigned char trlr[TRLR_LENGTH];
991
      int i;
992
      int err;
993
 
994
      if (mips_receive_header (hdr, &garbage, ch, timeout) != 0)
995
        {
996
          if (throw_error)
997
            mips_error ("Timed out waiting for remote packet");
998
          else
999
            return -1;
1000
        }
1001
 
1002
      ch = 0;
1003
 
1004
      /* An acknowledgement is probably a duplicate; ignore it.  */
1005
      if (!HDR_IS_DATA (hdr))
1006
        {
1007
          len = HDR_GET_LEN (hdr);
1008
          /* Check if the length is valid for an ACK, we may aswell
1009
             try and read the remainder of the packet: */
1010
          if (len == 0)
1011
            {
1012
              /* Ignore the error condition, since we are going to
1013
                 ignore the packet anyway. */
1014
              (void) mips_receive_trailer (trlr, &garbage, &ch, timeout);
1015
            }
1016
          /* Don't use _filtered; we can't deal with a QUIT out of
1017
             target_wait, and I think this might be called from there.  */
1018
          if (remote_debug > 0)
1019
            fprintf_unfiltered (gdb_stdlog, "Ignoring unexpected ACK\n");
1020
          continue;
1021
        }
1022
 
1023
      len = HDR_GET_LEN (hdr);
1024
      for (i = 0; i < len; i++)
1025
        {
1026
          int rch;
1027
 
1028
          rch = mips_readchar (timeout);
1029
          if (rch == SYN)
1030
            {
1031
              ch = SYN;
1032
              break;
1033
            }
1034
          if (rch == SERIAL_TIMEOUT)
1035
            {
1036
              if (throw_error)
1037
                mips_error ("Timed out waiting for remote packet");
1038
              else
1039
                return -1;
1040
            }
1041
          buff[i] = rch;
1042
        }
1043
 
1044
      if (i < len)
1045
        {
1046
          /* Don't use _filtered; we can't deal with a QUIT out of
1047
             target_wait, and I think this might be called from there.  */
1048
          if (remote_debug > 0)
1049
            fprintf_unfiltered (gdb_stdlog,
1050
                                "Got new SYN after %d chars (wanted %d)\n",
1051
                                i, len);
1052
          continue;
1053
        }
1054
 
1055
      err = mips_receive_trailer (trlr, &garbage, &ch, timeout);
1056
      if (err == -1)
1057
        {
1058
          if (throw_error)
1059
            mips_error ("Timed out waiting for packet");
1060
          else
1061
            return -1;
1062
        }
1063
      if (err == -2)
1064
        {
1065
          /* Don't use _filtered; we can't deal with a QUIT out of
1066
             target_wait, and I think this might be called from there.  */
1067
          if (remote_debug > 0)
1068
            fprintf_unfiltered (gdb_stdlog, "Got SYN when wanted trailer\n");
1069
          continue;
1070
        }
1071
 
1072
      /* If this is the wrong sequence number, ignore it.  */
1073
      if (HDR_GET_SEQ (hdr) != mips_receive_seq)
1074
        {
1075
          /* Don't use _filtered; we can't deal with a QUIT out of
1076
             target_wait, and I think this might be called from there.  */
1077
          if (remote_debug > 0)
1078
            fprintf_unfiltered (gdb_stdlog,
1079
                                "Ignoring sequence number %d (want %d)\n",
1080
                                HDR_GET_SEQ (hdr), mips_receive_seq);
1081
          continue;
1082
        }
1083
 
1084
      if (mips_cksum (hdr, buff, len) == TRLR_GET_CKSUM (trlr))
1085
        break;
1086
 
1087
      if (remote_debug > 0)
1088
        /* Don't use _filtered; we can't deal with a QUIT out of
1089
           target_wait, and I think this might be called from there.  */
1090
        printf_unfiltered ("Bad checksum; data %d, trailer %d\n",
1091
                           mips_cksum (hdr, buff, len),
1092
                           TRLR_GET_CKSUM (trlr));
1093
 
1094
      /* The checksum failed.  Send an acknowledgement for the
1095
         previous packet to tell the remote to resend the packet.  */
1096
      ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
1097
      ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
1098
      ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
1099
      ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
1100
 
1101
      cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
1102
 
1103
      ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
1104
      ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
1105
      ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
1106
 
1107
      if (remote_debug > 0)
1108
        {
1109
          ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
1110
          /* Don't use _filtered; we can't deal with a QUIT out of
1111
             target_wait, and I think this might be called from there.  */
1112
          printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
1113
                             ack + 1);
1114
        }
1115
 
1116
      if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
1117
        {
1118
          if (throw_error)
1119
            mips_error ("write to target failed: %s", safe_strerror (errno));
1120
          else
1121
            return -1;
1122
        }
1123
    }
1124
 
1125
  if (remote_debug > 0)
1126
    {
1127
      buff[len] = '\0';
1128
      /* Don't use _filtered; we can't deal with a QUIT out of
1129
         target_wait, and I think this might be called from there.  */
1130
      printf_unfiltered ("Got packet \"%s\"\n", buff);
1131
    }
1132
 
1133
  /* We got the packet.  Send an acknowledgement.  */
1134
  mips_receive_seq = (mips_receive_seq + 1) % SEQ_MODULOS;
1135
 
1136
  ack[HDR_INDX_SYN] = HDR_SET_SYN (0, 0, mips_receive_seq);
1137
  ack[HDR_INDX_TYPE_LEN] = HDR_SET_TYPE_LEN (0, 0, mips_receive_seq);
1138
  ack[HDR_INDX_LEN1] = HDR_SET_LEN1 (0, 0, mips_receive_seq);
1139
  ack[HDR_INDX_SEQ] = HDR_SET_SEQ (0, 0, mips_receive_seq);
1140
 
1141
  cksum = mips_cksum (ack, (unsigned char *) NULL, 0);
1142
 
1143
  ack[HDR_LENGTH + TRLR_INDX_CSUM1] = TRLR_SET_CSUM1 (cksum);
1144
  ack[HDR_LENGTH + TRLR_INDX_CSUM2] = TRLR_SET_CSUM2 (cksum);
1145
  ack[HDR_LENGTH + TRLR_INDX_CSUM3] = TRLR_SET_CSUM3 (cksum);
1146
 
1147
  if (remote_debug > 0)
1148
    {
1149
      ack[HDR_LENGTH + TRLR_LENGTH] = '\0';
1150
      /* Don't use _filtered; we can't deal with a QUIT out of
1151
         target_wait, and I think this might be called from there.  */
1152
      printf_unfiltered ("Writing ack %d \"%s\"\n", mips_receive_seq,
1153
                         ack + 1);
1154
    }
1155
 
1156
  if (serial_write (mips_desc, ack, HDR_LENGTH + TRLR_LENGTH) != 0)
1157
    {
1158
      if (throw_error)
1159
        mips_error ("write to target failed: %s", safe_strerror (errno));
1160
      else
1161
        return -1;
1162
    }
1163
 
1164
  return len;
1165
}
1166
 
1167
/* Optionally send a request to the remote system and optionally wait
1168
   for the reply.  This implements the remote debugging protocol,
1169
   which is built on top of the packet protocol defined above.  Each
1170
   request has an ADDR argument and a DATA argument.  The following
1171
   requests are defined:
1172
 
1173
   \0   don't send a request; just wait for a reply
1174
   i    read word from instruction space at ADDR
1175
   d    read word from data space at ADDR
1176
   I    write DATA to instruction space at ADDR
1177
   D    write DATA to data space at ADDR
1178
   r    read register number ADDR
1179
   R    set register number ADDR to value DATA
1180
   c    continue execution (if ADDR != 1, set pc to ADDR)
1181
   s    single step (if ADDR != 1, set pc to ADDR)
1182
 
1183
   The read requests return the value requested.  The write requests
1184
   return the previous value in the changed location.  The execution
1185
   requests return a UNIX wait value (the approximate signal which
1186
   caused execution to stop is in the upper eight bits).
1187
 
1188
   If PERR is not NULL, this function waits for a reply.  If an error
1189
   occurs, it sets *PERR to 1 and sets errno according to what the
1190
   target board reports.  */
1191
 
1192
static ULONGEST
1193
mips_request (int cmd,
1194
              ULONGEST addr,
1195
              ULONGEST data,
1196
              int *perr,
1197
              int timeout,
1198
              char *buff)
1199
{
1200
  char myBuff[DATA_MAXLEN + 1];
1201
  int len;
1202
  int rpid;
1203
  char rcmd;
1204
  int rerrflg;
1205
  unsigned long rresponse;
1206
 
1207
  if (buff == (char *) NULL)
1208
    buff = myBuff;
1209
 
1210
  if (cmd != '\0')
1211
    {
1212
      if (mips_need_reply)
1213
        internal_error (__FILE__, __LINE__,
1214
                        _("mips_request: Trying to send command before reply"));
1215
      sprintf (buff, "0x0 %c 0x%s 0x%s", cmd, paddr_nz (addr), paddr_nz (data));
1216
      mips_send_packet (buff, 1);
1217
      mips_need_reply = 1;
1218
    }
1219
 
1220
  if (perr == (int *) NULL)
1221
    return 0;
1222
 
1223
  if (!mips_need_reply)
1224
    internal_error (__FILE__, __LINE__,
1225
                    _("mips_request: Trying to get reply before command"));
1226
 
1227
  mips_need_reply = 0;
1228
 
1229
  len = mips_receive_packet (buff, 1, timeout);
1230
  buff[len] = '\0';
1231
 
1232
  if (sscanf (buff, "0x%x %c 0x%x 0x%lx",
1233
              &rpid, &rcmd, &rerrflg, &rresponse) != 4
1234
      || (cmd != '\0' && rcmd != cmd))
1235
    mips_error ("Bad response from remote board");
1236
 
1237
  if (rerrflg != 0)
1238
    {
1239
      *perr = 1;
1240
 
1241
      /* FIXME: This will returns MIPS errno numbers, which may or may
1242
         not be the same as errno values used on other systems.  If
1243
         they stick to common errno values, they will be the same, but
1244
         if they don't, they must be translated.  */
1245
      errno = rresponse;
1246
 
1247
      return 0;
1248
    }
1249
 
1250
  *perr = 0;
1251
  return rresponse;
1252
}
1253
 
1254
static void
1255
mips_initialize_cleanups (void *arg)
1256
{
1257
  mips_initializing = 0;
1258
}
1259
 
1260
static void
1261
mips_exit_cleanups (void *arg)
1262
{
1263
  mips_exiting = 0;
1264
}
1265
 
1266
static void
1267
mips_send_command (const char *cmd, int prompt)
1268
{
1269
  serial_write (mips_desc, cmd, strlen (cmd));
1270
  mips_expect (cmd);
1271
  mips_expect ("\n");
1272
  if (prompt)
1273
    mips_expect (mips_monitor_prompt);
1274
}
1275
 
1276
/* Enter remote (dbx) debug mode: */
1277
static void
1278
mips_enter_debug (void)
1279
{
1280
  /* Reset the sequence numbers, ready for the new debug sequence: */
1281
  mips_send_seq = 0;
1282
  mips_receive_seq = 0;
1283
 
1284
  if (mips_monitor != MON_IDT)
1285
    mips_send_command ("debug\r", 0);
1286
  else                          /* assume IDT monitor by default */
1287
    mips_send_command ("db tty0\r", 0);
1288
 
1289
  sleep (1);
1290
  serial_write (mips_desc, "\r", sizeof "\r" - 1);
1291
 
1292
  /* We don't need to absorb any spurious characters here, since the
1293
     mips_receive_header will eat up a reasonable number of characters
1294
     whilst looking for the SYN, however this avoids the "garbage"
1295
     being displayed to the user. */
1296
  if (mips_monitor != MON_IDT)
1297
    mips_expect ("\r");
1298
 
1299
  {
1300
    char buff[DATA_MAXLEN + 1];
1301
    if (mips_receive_packet (buff, 1, 3) < 0)
1302
      mips_error ("Failed to initialize (didn't receive packet).");
1303
  }
1304
}
1305
 
1306
/* Exit remote (dbx) debug mode, returning to the monitor prompt: */
1307
static int
1308
mips_exit_debug (void)
1309
{
1310
  int err;
1311
  struct cleanup *old_cleanups = make_cleanup (mips_exit_cleanups, NULL);
1312
 
1313
  mips_exiting = 1;
1314
 
1315
  if (mips_monitor != MON_IDT)
1316
    {
1317
      /* The DDB (NEC) and MiniRISC (LSI) versions of PMON exit immediately,
1318
         so we do not get a reply to this command: */
1319
      mips_request ('x', 0, 0, NULL, mips_receive_wait, NULL);
1320
      mips_need_reply = 0;
1321
      if (!mips_expect (" break!"))
1322
        return -1;
1323
    }
1324
  else
1325
    mips_request ('x', 0, 0, &err, mips_receive_wait, NULL);
1326
 
1327
  if (!mips_expect (mips_monitor_prompt))
1328
    return -1;
1329
 
1330
  do_cleanups (old_cleanups);
1331
 
1332
  return 0;
1333
}
1334
 
1335
/* Initialize a new connection to the MIPS board, and make sure we are
1336
   really connected.  */
1337
 
1338
static void
1339
mips_initialize (void)
1340
{
1341
  int err;
1342
  struct cleanup *old_cleanups = make_cleanup (mips_initialize_cleanups, NULL);
1343
  int j;
1344
 
1345
  /* What is this code doing here?  I don't see any way it can happen, and
1346
     it might mean mips_initializing didn't get cleared properly.
1347
     So I'll make it a warning.  */
1348
 
1349
  if (mips_initializing)
1350
    {
1351
      warning ("internal error: mips_initialize called twice");
1352
      return;
1353
    }
1354
 
1355
  mips_wait_flag = 0;
1356
  mips_initializing = 1;
1357
 
1358
  /* At this point, the packit protocol isn't responding.  We'll try getting
1359
     into the monitor, and restarting the protocol.  */
1360
 
1361
  /* Force the system into the monitor.  After this we *should* be at
1362
     the mips_monitor_prompt.  */
1363
  if (mips_monitor != MON_IDT)
1364
    j = 0;                       /* start by checking if we are already at the prompt */
1365
  else
1366
    j = 1;                      /* start by sending a break */
1367
  for (; j <= 4; j++)
1368
    {
1369
      switch (j)
1370
        {
1371
        case 0:          /* First, try sending a CR */
1372
          serial_flush_input (mips_desc);
1373
          serial_write (mips_desc, "\r", 1);
1374
          break;
1375
        case 1:         /* First, try sending a break */
1376
          serial_send_break (mips_desc);
1377
          break;
1378
        case 2:         /* Then, try a ^C */
1379
          serial_write (mips_desc, "\003", 1);
1380
          break;
1381
        case 3:         /* Then, try escaping from download */
1382
          {
1383
            if (mips_monitor != MON_IDT)
1384
              {
1385
                char tbuff[7];
1386
 
1387
                /* We shouldn't need to send multiple termination
1388
                   sequences, since the target performs line (or
1389
                   block) reads, and then processes those
1390
                   packets. In-case we were downloading a large packet
1391
                   we flush the output buffer before inserting a
1392
                   termination sequence. */
1393
                serial_flush_output (mips_desc);
1394
                sprintf (tbuff, "\r/E/E\r");
1395
                serial_write (mips_desc, tbuff, 6);
1396
              }
1397
            else
1398
              {
1399
                char srec[10];
1400
                int i;
1401
 
1402
                /* We are possibly in binary download mode, having
1403
                   aborted in the middle of an S-record.  ^C won't
1404
                   work because of binary mode.  The only reliable way
1405
                   out is to send enough termination packets (8 bytes)
1406
                   to fill up and then overflow the largest size
1407
                   S-record (255 bytes in this case).  This amounts to
1408
                   256/8 + 1 packets.
1409
                 */
1410
 
1411
                mips_make_srec (srec, '7', 0, NULL, 0);
1412
 
1413
                for (i = 1; i <= 33; i++)
1414
                  {
1415
                    serial_write (mips_desc, srec, 8);
1416
 
1417
                    if (serial_readchar (mips_desc, 0) >= 0)
1418
                      break;    /* Break immediatly if we get something from
1419
                                   the board. */
1420
                  }
1421
              }
1422
          }
1423
          break;
1424
        case 4:
1425
          mips_error ("Failed to initialize.");
1426
        }
1427
 
1428
      if (mips_expect (mips_monitor_prompt))
1429
        break;
1430
    }
1431
 
1432
  if (mips_monitor != MON_IDT)
1433
    {
1434
      /* Sometimes PMON ignores the first few characters in the first
1435
         command sent after a load.  Sending a blank command gets
1436
         around that.  */
1437
      mips_send_command ("\r", -1);
1438
 
1439
      /* Ensure the correct target state: */
1440
      if (mips_monitor != MON_LSI)
1441
        mips_send_command ("set regsize 64\r", -1);
1442
      mips_send_command ("set hostport tty0\r", -1);
1443
      mips_send_command ("set brkcmd \"\"\r", -1);
1444
      /* Delete all the current breakpoints: */
1445
      mips_send_command ("db *\r", -1);
1446
      /* NOTE: PMON does not have breakpoint support through the
1447
         "debug" mode, only at the monitor command-line. */
1448
    }
1449
 
1450
  mips_enter_debug ();
1451
 
1452
  /* Clear all breakpoints: */
1453
  if ((mips_monitor == MON_IDT
1454
       && mips_clear_breakpoint (-1, 0, BREAK_UNUSED) == 0)
1455
      || mips_monitor == MON_LSI)
1456
    monitor_supports_breakpoints = 1;
1457
  else
1458
    monitor_supports_breakpoints = 0;
1459
 
1460
  do_cleanups (old_cleanups);
1461
 
1462
  /* If this doesn't call error, we have connected; we don't care if
1463
     the request itself succeeds or fails.  */
1464
 
1465
  mips_request ('r', 0, 0, &err, mips_receive_wait, NULL);
1466
}
1467
 
1468
/* Open a connection to the remote board.  */
1469
static void
1470
common_open (struct target_ops *ops, char *name, int from_tty,
1471
             enum mips_monitor_type new_monitor,
1472
             const char *new_monitor_prompt)
1473
{
1474
  char *ptype;
1475
  char *serial_port_name;
1476
  char *remote_name = 0;
1477
  char *local_name = 0;
1478
  char **argv;
1479
 
1480
  if (name == 0)
1481
    error (
1482
            "To open a MIPS remote debugging connection, you need to specify what serial\n\
1483
device is attached to the target board (e.g., /dev/ttya).\n"
1484
            "If you want to use TFTP to download to the board, specify the name of a\n"
1485
            "temporary file to be used by GDB for downloads as the second argument.\n"
1486
            "This filename must be in the form host:filename, where host is the name\n"
1487
            "of the host running the TFTP server, and the file must be readable by the\n"
1488
            "world.  If the local name of the temporary file differs from the name as\n"
1489
            "seen from the board via TFTP, specify that name as the third parameter.\n");
1490
 
1491
  /* Parse the serial port name, the optional TFTP name, and the
1492
     optional local TFTP name.  */
1493
  if ((argv = buildargv (name)) == NULL)
1494
    nomem (0);
1495
  make_cleanup_freeargv (argv);
1496
 
1497
  serial_port_name = xstrdup (argv[0]);
1498
  if (argv[1])                  /* remote TFTP name specified? */
1499
    {
1500
      remote_name = argv[1];
1501
      if (argv[2])              /* local TFTP filename specified? */
1502
        local_name = argv[2];
1503
    }
1504
 
1505
  target_preopen (from_tty);
1506
 
1507
  if (mips_is_open)
1508
    unpush_target (current_ops);
1509
 
1510
  /* Open and initialize the serial port.  */
1511
  mips_desc = serial_open (serial_port_name);
1512
  if (mips_desc == NULL)
1513
    perror_with_name (serial_port_name);
1514
 
1515
  if (baud_rate != -1)
1516
    {
1517
      if (serial_setbaudrate (mips_desc, baud_rate))
1518
        {
1519
          serial_close (mips_desc);
1520
          perror_with_name (serial_port_name);
1521
        }
1522
    }
1523
 
1524
  serial_raw (mips_desc);
1525
 
1526
  /* Open and initialize the optional download port.  If it is in the form
1527
     hostname#portnumber, it's a UDP socket.  If it is in the form
1528
     hostname:filename, assume it's the TFTP filename that must be
1529
     passed to the DDB board to tell it where to get the load file.  */
1530
  if (remote_name)
1531
    {
1532
      if (strchr (remote_name, '#'))
1533
        {
1534
          udp_desc = serial_open (remote_name);
1535
          if (!udp_desc)
1536
            perror_with_name ("Unable to open UDP port");
1537
          udp_in_use = 1;
1538
        }
1539
      else
1540
        {
1541
          /* Save the remote and local names of the TFTP temp file.  If
1542
             the user didn't specify a local name, assume it's the same
1543
             as the part of the remote name after the "host:".  */
1544
          if (tftp_name)
1545
            xfree (tftp_name);
1546
          if (tftp_localname)
1547
            xfree (tftp_localname);
1548
          if (local_name == NULL)
1549
            if ((local_name = strchr (remote_name, ':')) != NULL)
1550
              local_name++;     /* skip over the colon */
1551
          if (local_name == NULL)
1552
            local_name = remote_name;   /* local name same as remote name */
1553
          tftp_name = xstrdup (remote_name);
1554
          tftp_localname = xstrdup (local_name);
1555
          tftp_in_use = 1;
1556
        }
1557
    }
1558
 
1559
  current_ops = ops;
1560
  mips_is_open = 1;
1561
 
1562
  /* Reset the expected monitor prompt if it's never been set before.  */
1563
  if (mips_monitor_prompt == NULL)
1564
    mips_monitor_prompt = xstrdup (new_monitor_prompt);
1565
  mips_monitor = new_monitor;
1566
 
1567
  mips_initialize ();
1568
 
1569
  if (from_tty)
1570
    printf_unfiltered ("Remote MIPS debugging using %s\n", serial_port_name);
1571
 
1572
  /* Switch to using remote target now.  */
1573
  push_target (ops);
1574
 
1575
  /* FIXME: Should we call start_remote here?  */
1576
 
1577
  /* Try to figure out the processor model if possible.  */
1578
  deprecated_mips_set_processor_regs_hack ();
1579
 
1580
  /* This is really the job of start_remote however, that makes an
1581
     assumption that the target is about to print out a status message
1582
     of some sort.  That doesn't happen here (in fact, it may not be
1583
     possible to get the monitor to send the appropriate packet).  */
1584
 
1585
  reinit_frame_cache ();
1586
  registers_changed ();
1587
  stop_pc = read_pc ();
1588
  print_stack_frame (get_selected_frame (NULL), 0, SRC_AND_LOC);
1589
  xfree (serial_port_name);
1590
}
1591
 
1592
static void
1593
mips_open (char *name, int from_tty)
1594
{
1595
  const char *monitor_prompt = NULL;
1596
  if (gdbarch_bfd_arch_info (current_gdbarch) != NULL
1597
      && gdbarch_bfd_arch_info (current_gdbarch)->arch == bfd_arch_mips)
1598
    {
1599
    switch (gdbarch_bfd_arch_info (current_gdbarch)->mach)
1600
      {
1601
      case bfd_mach_mips4100:
1602
      case bfd_mach_mips4300:
1603
      case bfd_mach_mips4600:
1604
      case bfd_mach_mips4650:
1605
      case bfd_mach_mips5000:
1606
        monitor_prompt = "<RISQ> ";
1607
        break;
1608
      }
1609
    }
1610
  if (monitor_prompt == NULL)
1611
    monitor_prompt = "<IDT>";
1612
  common_open (&mips_ops, name, from_tty, MON_IDT, monitor_prompt);
1613
}
1614
 
1615
static void
1616
pmon_open (char *name, int from_tty)
1617
{
1618
  common_open (&pmon_ops, name, from_tty, MON_PMON, "PMON> ");
1619
}
1620
 
1621
static void
1622
ddb_open (char *name, int from_tty)
1623
{
1624
  common_open (&ddb_ops, name, from_tty, MON_DDB, "NEC010>");
1625
}
1626
 
1627
static void
1628
lsi_open (char *name, int from_tty)
1629
{
1630
  int i;
1631
 
1632
  /* Clear the LSI breakpoint table.  */
1633
  for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
1634
    lsi_breakpoints[i].type = BREAK_UNUSED;
1635
 
1636
  common_open (&lsi_ops, name, from_tty, MON_LSI, "PMON> ");
1637
}
1638
 
1639
/* Close a connection to the remote board.  */
1640
 
1641
static void
1642
mips_close (int quitting)
1643
{
1644
  if (mips_is_open)
1645
    {
1646
      /* Get the board out of remote debugging mode.  */
1647
      (void) mips_exit_debug ();
1648
 
1649
      close_ports ();
1650
    }
1651
}
1652
 
1653
/* Detach from the remote board.  */
1654
 
1655
static void
1656
mips_detach (char *args, int from_tty)
1657
{
1658
  if (args)
1659
    error ("Argument given to \"detach\" when remotely debugging.");
1660
 
1661
  pop_target ();
1662
 
1663
  mips_close (1);
1664
 
1665
  if (from_tty)
1666
    printf_unfiltered ("Ending remote MIPS debugging.\n");
1667
}
1668
 
1669
/* Tell the target board to resume.  This does not wait for a reply
1670
   from the board, except in the case of single-stepping on LSI boards,
1671
   where PMON does return a reply.  */
1672
 
1673
static void
1674
mips_resume (ptid_t ptid, int step, enum target_signal siggnal)
1675
{
1676
  int err;
1677
 
1678
  /* LSI PMON requires returns a reply packet "0x1 s 0x0 0x57f" after
1679
     a single step, so we wait for that.  */
1680
  mips_request (step ? 's' : 'c', 1, siggnal,
1681
                mips_monitor == MON_LSI && step ? &err : (int *) NULL,
1682
                mips_receive_wait, NULL);
1683
}
1684
 
1685
/* Return the signal corresponding to SIG, where SIG is the number which
1686
   the MIPS protocol uses for the signal.  */
1687
static enum target_signal
1688
mips_signal_from_protocol (int sig)
1689
{
1690
  /* We allow a few more signals than the IDT board actually returns, on
1691
     the theory that there is at least *some* hope that perhaps the numbering
1692
     for these signals is widely agreed upon.  */
1693
  if (sig <= 0
1694
      || sig > 31)
1695
    return TARGET_SIGNAL_UNKNOWN;
1696
 
1697
  /* Don't want to use target_signal_from_host because we are converting
1698
     from MIPS signal numbers, not host ones.  Our internal numbers
1699
     match the MIPS numbers for the signals the board can return, which
1700
     are: SIGINT, SIGSEGV, SIGBUS, SIGILL, SIGFPE, SIGTRAP.  */
1701
  return (enum target_signal) sig;
1702
}
1703
 
1704
/* Wait until the remote stops, and return a wait status.  */
1705
 
1706
static ptid_t
1707
mips_wait (ptid_t ptid, struct target_waitstatus *status)
1708
{
1709
  int rstatus;
1710
  int err;
1711
  char buff[DATA_MAXLEN];
1712
  int rpc, rfp, rsp;
1713
  char flags[20];
1714
  int nfields;
1715
  int i;
1716
 
1717
  interrupt_count = 0;
1718
  hit_watchpoint = 0;
1719
 
1720
  /* If we have not sent a single step or continue command, then the
1721
     board is waiting for us to do something.  Return a status
1722
     indicating that it is stopped.  */
1723
  if (!mips_need_reply)
1724
    {
1725
      status->kind = TARGET_WAITKIND_STOPPED;
1726
      status->value.sig = TARGET_SIGNAL_TRAP;
1727
      return inferior_ptid;
1728
    }
1729
 
1730
  /* No timeout; we sit here as long as the program continues to execute.  */
1731
  mips_wait_flag = 1;
1732
  rstatus = mips_request ('\000', 0, 0, &err, -1, buff);
1733
  mips_wait_flag = 0;
1734
  if (err)
1735
    mips_error ("Remote failure: %s", safe_strerror (errno));
1736
 
1737
  /* On returning from a continue, the PMON monitor seems to start
1738
     echoing back the messages we send prior to sending back the
1739
     ACK. The code can cope with this, but to try and avoid the
1740
     unnecessary serial traffic, and "spurious" characters displayed
1741
     to the user, we cheat and reset the debug protocol. The problems
1742
     seems to be caused by a check on the number of arguments, and the
1743
     command length, within the monitor causing it to echo the command
1744
     as a bad packet. */
1745
  if (mips_monitor == MON_PMON)
1746
    {
1747
      mips_exit_debug ();
1748
      mips_enter_debug ();
1749
    }
1750
 
1751
  /* See if we got back extended status.  If so, pick out the pc, fp, sp, etc... */
1752
 
1753
  nfields = sscanf (buff, "0x%*x %*c 0x%*x 0x%*x 0x%x 0x%x 0x%x 0x%*x %s",
1754
                    &rpc, &rfp, &rsp, flags);
1755
  if (nfields >= 3)
1756
    {
1757
      struct regcache *regcache = get_current_regcache ();
1758
      struct gdbarch *gdbarch = get_regcache_arch (regcache);
1759
      char buf[MAX_REGISTER_SIZE];
1760
 
1761
      store_unsigned_integer (buf,
1762
                              register_size
1763
                                (gdbarch, gdbarch_pc_regnum (gdbarch)), rpc);
1764
      regcache_raw_supply (regcache, gdbarch_pc_regnum (gdbarch), buf);
1765
 
1766
      store_unsigned_integer
1767
        (buf, register_size (gdbarch, gdbarch_pc_regnum (gdbarch)), rfp);
1768
      regcache_raw_supply (regcache, 30, buf);  /* This register they are avoiding and so it is unnamed */
1769
 
1770
      store_unsigned_integer (buf, register_size (gdbarch,
1771
                              gdbarch_sp_regnum (gdbarch)), rsp);
1772
      regcache_raw_supply (regcache, gdbarch_sp_regnum (gdbarch), buf);
1773
 
1774
      store_unsigned_integer (buf,
1775
                              register_size (gdbarch,
1776
                                             gdbarch_deprecated_fp_regnum
1777
                                               (gdbarch)),
1778
                              0);
1779
      regcache_raw_supply (regcache,
1780
                           gdbarch_deprecated_fp_regnum (gdbarch), buf);
1781
 
1782
      if (nfields == 9)
1783
        {
1784
          int i;
1785
 
1786
          for (i = 0; i <= 2; i++)
1787
            if (flags[i] == 'r' || flags[i] == 'w')
1788
              hit_watchpoint = 1;
1789
            else if (flags[i] == '\000')
1790
              break;
1791
        }
1792
    }
1793
 
1794
  if (strcmp (target_shortname, "lsi") == 0)
1795
    {
1796
#if 0
1797
      /* If this is an LSI PMON target, see if we just hit a hardrdware watchpoint.
1798
         Right now, PMON doesn't give us enough information to determine which
1799
         breakpoint we hit.  So we have to look up the PC in our own table
1800
         of breakpoints, and if found, assume it's just a normal instruction
1801
         fetch breakpoint, not a data watchpoint.  FIXME when PMON
1802
         provides some way to tell us what type of breakpoint it is.  */
1803
      int i;
1804
      CORE_ADDR pc = read_pc ();
1805
 
1806
      hit_watchpoint = 1;
1807
      for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
1808
        {
1809
          if (lsi_breakpoints[i].addr == pc
1810
              && lsi_breakpoints[i].type == BREAK_FETCH)
1811
            {
1812
              hit_watchpoint = 0;
1813
              break;
1814
            }
1815
        }
1816
#else
1817
      /* If a data breakpoint was hit, PMON returns the following packet:
1818
         0x1 c 0x0 0x57f 0x1
1819
         The return packet from an ordinary breakpoint doesn't have the
1820
         extra 0x01 field tacked onto the end.  */
1821
      if (nfields == 1 && rpc == 1)
1822
        hit_watchpoint = 1;
1823
#endif
1824
    }
1825
 
1826
  /* NOTE: The following (sig) numbers are defined by PMON:
1827
     SPP_SIGTRAP     5       breakpoint
1828
     SPP_SIGINT      2
1829
     SPP_SIGSEGV     11
1830
     SPP_SIGBUS      10
1831
     SPP_SIGILL      4
1832
     SPP_SIGFPE      8
1833
     SPP_SIGTERM     15 */
1834
 
1835
  /* Translate a MIPS waitstatus.  We use constants here rather than WTERMSIG
1836
     and so on, because the constants we want here are determined by the
1837
     MIPS protocol and have nothing to do with what host we are running on.  */
1838
  if ((rstatus & 0xff) == 0)
1839
    {
1840
      status->kind = TARGET_WAITKIND_EXITED;
1841
      status->value.integer = (((rstatus) >> 8) & 0xff);
1842
    }
1843
  else if ((rstatus & 0xff) == 0x7f)
1844
    {
1845
      status->kind = TARGET_WAITKIND_STOPPED;
1846
      status->value.sig = mips_signal_from_protocol (((rstatus) >> 8) & 0xff);
1847
 
1848
      /* If the stop PC is in the _exit function, assume
1849
         we hit the 'break 0x3ff' instruction in _exit, so this
1850
         is not a normal breakpoint.  */
1851
      if (strcmp (target_shortname, "lsi") == 0)
1852
        {
1853
          char *func_name;
1854
          CORE_ADDR func_start;
1855
          CORE_ADDR pc = read_pc ();
1856
 
1857
          find_pc_partial_function (pc, &func_name, &func_start, NULL);
1858
          if (func_name != NULL && strcmp (func_name, "_exit") == 0
1859
              && func_start == pc)
1860
            status->kind = TARGET_WAITKIND_EXITED;
1861
        }
1862
    }
1863
  else
1864
    {
1865
      status->kind = TARGET_WAITKIND_SIGNALLED;
1866
      status->value.sig = mips_signal_from_protocol (rstatus & 0x7f);
1867
    }
1868
 
1869
  return inferior_ptid;
1870
}
1871
 
1872
/* We have to map between the register numbers used by gdb and the
1873
   register numbers used by the debugging protocol.  */
1874
 
1875
#define REGNO_OFFSET 96
1876
 
1877
static int
1878
mips_map_regno (int regno)
1879
{
1880
  if (regno < 32)
1881
    return regno;
1882
  if (regno >= mips_regnum (current_gdbarch)->fp0
1883
      && regno < mips_regnum (current_gdbarch)->fp0 + 32)
1884
    return regno - mips_regnum (current_gdbarch)->fp0 + 32;
1885
  else if (regno == mips_regnum (current_gdbarch)->pc)
1886
    return REGNO_OFFSET + 0;
1887
  else if (regno == mips_regnum (current_gdbarch)->cause)
1888
    return REGNO_OFFSET + 1;
1889
  else if (regno == mips_regnum (current_gdbarch)->hi)
1890
    return REGNO_OFFSET + 2;
1891
  else if (regno == mips_regnum (current_gdbarch)->lo)
1892
    return REGNO_OFFSET + 3;
1893
  else if (regno == mips_regnum (current_gdbarch)->fp_control_status)
1894
    return REGNO_OFFSET + 4;
1895
  else if (regno == mips_regnum (current_gdbarch)->fp_implementation_revision)
1896
    return REGNO_OFFSET + 5;
1897
  else
1898
    /* FIXME: Is there a way to get the status register?  */
1899
    return 0;
1900
}
1901
 
1902
/* Fetch the remote registers.  */
1903
 
1904
static void
1905
mips_fetch_registers (struct regcache *regcache, int regno)
1906
{
1907
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1908
  unsigned LONGEST val;
1909
  int err;
1910
 
1911
  if (regno == -1)
1912
    {
1913
      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
1914
        mips_fetch_registers (regcache, regno);
1915
      return;
1916
    }
1917
 
1918
  if (regno == gdbarch_deprecated_fp_regnum (gdbarch)
1919
      || regno == MIPS_ZERO_REGNUM)
1920
    /* gdbarch_deprecated_fp_regnum on the mips is a hack which is just
1921
       supposed to read zero (see also mips-nat.c).  */
1922
    val = 0;
1923
  else
1924
    {
1925
      /* If PMON doesn't support this register, don't waste serial
1926
         bandwidth trying to read it.  */
1927
      int pmon_reg = mips_map_regno (regno);
1928
      if (regno != 0 && pmon_reg == 0)
1929
        val = 0;
1930
      else
1931
        {
1932
          /* Unfortunately the PMON version in the Vr4300 board has been
1933
             compiled without the 64bit register access commands. This
1934
             means we cannot get hold of the full register width. */
1935
          if (mips_monitor == MON_DDB)
1936
            val = (unsigned) mips_request ('t', pmon_reg, 0,
1937
                                           &err, mips_receive_wait, NULL);
1938
          else
1939
            val = mips_request ('r', pmon_reg, 0,
1940
                                &err, mips_receive_wait, NULL);
1941
          if (err)
1942
            mips_error ("Can't read register %d: %s", regno,
1943
                        safe_strerror (errno));
1944
        }
1945
    }
1946
 
1947
  {
1948
    char buf[MAX_REGISTER_SIZE];
1949
 
1950
    /* We got the number the register holds, but gdb expects to see a
1951
       value in the target byte ordering.  */
1952
    store_unsigned_integer (buf, register_size (gdbarch, regno), val);
1953
    regcache_raw_supply (regcache, regno, buf);
1954
  }
1955
}
1956
 
1957
/* Prepare to store registers.  The MIPS protocol can store individual
1958
   registers, so this function doesn't have to do anything.  */
1959
 
1960
static void
1961
mips_prepare_to_store (struct regcache *regcache)
1962
{
1963
}
1964
 
1965
/* Store remote register(s).  */
1966
 
1967
static void
1968
mips_store_registers (struct regcache *regcache, int regno)
1969
{
1970
  struct gdbarch *gdbarch = get_regcache_arch (regcache);
1971
  ULONGEST val;
1972
  int err;
1973
 
1974
  if (regno == -1)
1975
    {
1976
      for (regno = 0; regno < gdbarch_num_regs (gdbarch); regno++)
1977
        mips_store_registers (regcache, regno);
1978
      return;
1979
    }
1980
 
1981
  regcache_cooked_read_unsigned (regcache, regno, &val);
1982
  mips_request ('R', mips_map_regno (regno), val,
1983
                &err, mips_receive_wait, NULL);
1984
  if (err)
1985
    mips_error ("Can't write register %d: %s", regno, safe_strerror (errno));
1986
}
1987
 
1988
/* Fetch a word from the target board.  */
1989
 
1990
static unsigned int
1991
mips_fetch_word (CORE_ADDR addr)
1992
{
1993
  unsigned int val;
1994
  int err;
1995
 
1996
  val = mips_request ('d', addr, 0, &err, mips_receive_wait, NULL);
1997
  if (err)
1998
    {
1999
      /* Data space failed; try instruction space.  */
2000
      val = mips_request ('i', addr, 0, &err,
2001
                          mips_receive_wait, NULL);
2002
      if (err)
2003
        mips_error ("Can't read address 0x%s: %s",
2004
                    paddr_nz (addr), safe_strerror (errno));
2005
    }
2006
  return val;
2007
}
2008
 
2009
/* Store a word to the target board.  Returns errno code or zero for
2010
   success.  If OLD_CONTENTS is non-NULL, put the old contents of that
2011
   memory location there.  */
2012
 
2013
/* FIXME! make sure only 32-bit quantities get stored! */
2014
static int
2015
mips_store_word (CORE_ADDR addr, unsigned int val, char *old_contents)
2016
{
2017
  int err;
2018
  unsigned int oldcontents;
2019
 
2020
  oldcontents = mips_request ('D', addr, val, &err,
2021
                              mips_receive_wait, NULL);
2022
  if (err)
2023
    {
2024
      /* Data space failed; try instruction space.  */
2025
      oldcontents = mips_request ('I', addr, val, &err,
2026
                                  mips_receive_wait, NULL);
2027
      if (err)
2028
        return errno;
2029
    }
2030
  if (old_contents != NULL)
2031
    store_unsigned_integer (old_contents, 4, oldcontents);
2032
  return 0;
2033
}
2034
 
2035
/* Read or write LEN bytes from inferior memory at MEMADDR,
2036
   transferring to or from debugger address MYADDR.  Write to inferior
2037
   if SHOULD_WRITE is nonzero.  Returns length of data written or
2038
   read; 0 for error.  Note that protocol gives us the correct value
2039
   for a longword, since it transfers values in ASCII.  We want the
2040
   byte values, so we have to swap the longword values.  */
2041
 
2042
static int mask_address_p = 1;
2043
 
2044
static int
2045
mips_xfer_memory (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int write,
2046
                  struct mem_attrib *attrib, struct target_ops *target)
2047
{
2048
  int i;
2049
  CORE_ADDR addr;
2050
  int count;
2051
  char *buffer;
2052
  int status;
2053
 
2054
  /* PMON targets do not cope well with 64 bit addresses.  Mask the
2055
     value down to 32 bits. */
2056
  if (mask_address_p)
2057
    memaddr &= (CORE_ADDR) 0xffffffff;
2058
 
2059
  /* Round starting address down to longword boundary.  */
2060
  addr = memaddr & ~3;
2061
  /* Round ending address up; get number of longwords that makes.  */
2062
  count = (((memaddr + len) - addr) + 3) / 4;
2063
  /* Allocate buffer of that many longwords.  */
2064
  buffer = alloca (count * 4);
2065
 
2066
  if (write)
2067
    {
2068
      /* Fill start and end extra bytes of buffer with existing data.  */
2069
      if (addr != memaddr || len < 4)
2070
        {
2071
          /* Need part of initial word -- fetch it.  */
2072
          store_unsigned_integer (&buffer[0], 4, mips_fetch_word (addr));
2073
        }
2074
 
2075
      if (count > 1)
2076
        {
2077
          /* Need part of last word -- fetch it.  FIXME: we do this even
2078
             if we don't need it.  */
2079
          store_unsigned_integer (&buffer[(count - 1) * 4], 4,
2080
                                  mips_fetch_word (addr + (count - 1) * 4));
2081
        }
2082
 
2083
      /* Copy data to be written over corresponding part of buffer */
2084
 
2085
      memcpy ((char *) buffer + (memaddr & 3), myaddr, len);
2086
 
2087
      /* Write the entire buffer.  */
2088
 
2089
      for (i = 0; i < count; i++, addr += 4)
2090
        {
2091
          status = mips_store_word (addr,
2092
                               extract_unsigned_integer (&buffer[i * 4], 4),
2093
                                    NULL);
2094
          /* Report each kilobyte (we download 32-bit words at a time) */
2095
          if (i % 256 == 255)
2096
            {
2097
              printf_unfiltered ("*");
2098
              gdb_flush (gdb_stdout);
2099
            }
2100
          if (status)
2101
            {
2102
              errno = status;
2103
              return 0;
2104
            }
2105
          /* FIXME: Do we want a QUIT here?  */
2106
        }
2107
      if (count >= 256)
2108
        printf_unfiltered ("\n");
2109
    }
2110
  else
2111
    {
2112
      /* Read all the longwords */
2113
      for (i = 0; i < count; i++, addr += 4)
2114
        {
2115
          store_unsigned_integer (&buffer[i * 4], 4, mips_fetch_word (addr));
2116
          QUIT;
2117
        }
2118
 
2119
      /* Copy appropriate bytes out of the buffer.  */
2120
      memcpy (myaddr, buffer + (memaddr & 3), len);
2121
    }
2122
  return len;
2123
}
2124
 
2125
/* Print info on this target.  */
2126
 
2127
static void
2128
mips_files_info (struct target_ops *ignore)
2129
{
2130
  printf_unfiltered ("Debugging a MIPS board over a serial line.\n");
2131
}
2132
 
2133
/* Kill the process running on the board.  This will actually only
2134
   work if we are doing remote debugging over the console input.  I
2135
   think that if IDT/sim had the remote debug interrupt enabled on the
2136
   right port, we could interrupt the process with a break signal.  */
2137
 
2138
static void
2139
mips_kill (void)
2140
{
2141
  if (!mips_wait_flag)
2142
    return;
2143
 
2144
  interrupt_count++;
2145
 
2146
  if (interrupt_count >= 2)
2147
    {
2148
      interrupt_count = 0;
2149
 
2150
      target_terminal_ours ();
2151
 
2152
      if (query ("Interrupted while waiting for the program.\n\
2153
Give up (and stop debugging it)? "))
2154
        {
2155
          /* Clean up in such a way that mips_close won't try to talk to the
2156
             board (it almost surely won't work since we weren't able to talk to
2157
             it).  */
2158
          mips_wait_flag = 0;
2159
          close_ports ();
2160
 
2161
          printf_unfiltered ("Ending remote MIPS debugging.\n");
2162
          target_mourn_inferior ();
2163
 
2164
          deprecated_throw_reason (RETURN_QUIT);
2165
        }
2166
 
2167
      target_terminal_inferior ();
2168
    }
2169
 
2170
  if (remote_debug > 0)
2171
    printf_unfiltered ("Sending break\n");
2172
 
2173
  serial_send_break (mips_desc);
2174
 
2175
#if 0
2176
  if (mips_is_open)
2177
    {
2178
      char cc;
2179
 
2180
      /* Send a ^C.  */
2181
      cc = '\003';
2182
      serial_write (mips_desc, &cc, 1);
2183
      sleep (1);
2184
      target_mourn_inferior ();
2185
    }
2186
#endif
2187
}
2188
 
2189
/* Start running on the target board.  */
2190
 
2191
static void
2192
mips_create_inferior (char *execfile, char *args, char **env, int from_tty)
2193
{
2194
  CORE_ADDR entry_pt;
2195
 
2196
  if (args && *args)
2197
    {
2198
      warning ("\
2199
Can't pass arguments to remote MIPS board; arguments ignored.");
2200
      /* And don't try to use them on the next "run" command.  */
2201
      execute_command ("set args", 0);
2202
    }
2203
 
2204
  if (execfile == 0 || exec_bfd == 0)
2205
    error ("No executable file specified");
2206
 
2207
  entry_pt = (CORE_ADDR) bfd_get_start_address (exec_bfd);
2208
 
2209
  init_wait_for_inferior ();
2210
 
2211
  /* FIXME: Should we set inferior_ptid here?  */
2212
 
2213
  write_pc (entry_pt);
2214
}
2215
 
2216
/* Clean up after a process.  Actually nothing to do.  */
2217
 
2218
static void
2219
mips_mourn_inferior (void)
2220
{
2221
  if (current_ops != NULL)
2222
    unpush_target (current_ops);
2223
  generic_mourn_inferior ();
2224
}
2225
 
2226
/* We can write a breakpoint and read the shadow contents in one
2227
   operation.  */
2228
 
2229
/* Insert a breakpoint.  On targets that don't have built-in
2230
   breakpoint support, we read the contents of the target location and
2231
   stash it, then overwrite it with a breakpoint instruction.  ADDR is
2232
   the target location in the target machine.  BPT is the breakpoint
2233
   being inserted or removed, which contains memory for saving the
2234
   target contents.  */
2235
 
2236
static int
2237
mips_insert_breakpoint (struct bp_target_info *bp_tgt)
2238
{
2239
  if (monitor_supports_breakpoints)
2240
    return mips_set_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
2241
                                BREAK_FETCH);
2242
  else
2243
    return memory_insert_breakpoint (bp_tgt);
2244
}
2245
 
2246
static int
2247
mips_remove_breakpoint (struct bp_target_info *bp_tgt)
2248
{
2249
  if (monitor_supports_breakpoints)
2250
    return mips_clear_breakpoint (bp_tgt->placed_address, MIPS_INSN32_SIZE,
2251
                                  BREAK_FETCH);
2252
  else
2253
    return memory_remove_breakpoint (bp_tgt);
2254
}
2255
 
2256
/* Tell whether this target can support a hardware breakpoint.  CNT
2257
   is the number of hardware breakpoints already installed.  This
2258
   implements the TARGET_CAN_USE_HARDWARE_WATCHPOINT macro.  */
2259
 
2260
int
2261
mips_can_use_watchpoint (int type, int cnt, int othertype)
2262
{
2263
  return cnt < MAX_LSI_BREAKPOINTS && strcmp (target_shortname, "lsi") == 0;
2264
}
2265
 
2266
 
2267
/* Compute a don't care mask for the region bounding ADDR and ADDR + LEN - 1.
2268
   This is used for memory ref breakpoints.  */
2269
 
2270
static unsigned long
2271
calculate_mask (CORE_ADDR addr, int len)
2272
{
2273
  unsigned long mask;
2274
  int i;
2275
 
2276
  mask = addr ^ (addr + len - 1);
2277
 
2278
  for (i = 32; i >= 0; i--)
2279
    if (mask == 0)
2280
      break;
2281
    else
2282
      mask >>= 1;
2283
 
2284
  mask = (unsigned long) 0xffffffff >> i;
2285
 
2286
  return mask;
2287
}
2288
 
2289
 
2290
/* Set a data watchpoint.  ADDR and LEN should be obvious.  TYPE is 0
2291
   for a write watchpoint, 1 for a read watchpoint, or 2 for a read/write
2292
   watchpoint. */
2293
 
2294
int
2295
mips_insert_watchpoint (CORE_ADDR addr, int len, int type)
2296
{
2297
  if (mips_set_breakpoint (addr, len, type))
2298
    return -1;
2299
 
2300
  return 0;
2301
}
2302
 
2303
int
2304
mips_remove_watchpoint (CORE_ADDR addr, int len, int type)
2305
{
2306
  if (mips_clear_breakpoint (addr, len, type))
2307
    return -1;
2308
 
2309
  return 0;
2310
}
2311
 
2312
int
2313
mips_stopped_by_watchpoint (void)
2314
{
2315
  return hit_watchpoint;
2316
}
2317
 
2318
 
2319
/* Insert a breakpoint.  */
2320
 
2321
static int
2322
mips_set_breakpoint (CORE_ADDR addr, int len, enum break_type type)
2323
{
2324
  return mips_common_breakpoint (1, addr, len, type);
2325
}
2326
 
2327
 
2328
/* Clear a breakpoint.  */
2329
 
2330
static int
2331
mips_clear_breakpoint (CORE_ADDR addr, int len, enum break_type type)
2332
{
2333
  return mips_common_breakpoint (0, addr, len, type);
2334
}
2335
 
2336
 
2337
/* Check the error code from the return packet for an LSI breakpoint
2338
   command.  If there's no error, just return 0.  If it's a warning,
2339
   print the warning text and return 0.  If it's an error, print
2340
   the error text and return 1.  <ADDR> is the address of the breakpoint
2341
   that was being set.  <RERRFLG> is the error code returned by PMON.
2342
   This is a helper function for mips_common_breakpoint.  */
2343
 
2344
static int
2345
mips_check_lsi_error (CORE_ADDR addr, int rerrflg)
2346
{
2347
  struct lsi_error *err;
2348
  char *saddr = paddr_nz (addr);        /* printable address string */
2349
 
2350
  if (rerrflg == 0)              /* no error */
2351
    return 0;
2352
 
2353
  /* Warnings can be ORed together, so check them all.  */
2354
  if (rerrflg & W_WARN)
2355
    {
2356
      if (monitor_warnings)
2357
        {
2358
          int found = 0;
2359
          for (err = lsi_warning_table; err->code != 0; err++)
2360
            {
2361
              if ((err->code & rerrflg) == err->code)
2362
                {
2363
                  found = 1;
2364
                  fprintf_unfiltered (gdb_stderr, "\
2365
mips_common_breakpoint (0x%s): Warning: %s\n",
2366
                                      saddr,
2367
                                      err->string);
2368
                }
2369
            }
2370
          if (!found)
2371
            fprintf_unfiltered (gdb_stderr, "\
2372
mips_common_breakpoint (0x%s): Unknown warning: 0x%x\n",
2373
                                saddr,
2374
                                rerrflg);
2375
        }
2376
      return 0;
2377
    }
2378
 
2379
  /* Errors are unique, i.e. can't be ORed together.  */
2380
  for (err = lsi_error_table; err->code != 0; err++)
2381
    {
2382
      if ((err->code & rerrflg) == err->code)
2383
        {
2384
          fprintf_unfiltered (gdb_stderr, "\
2385
mips_common_breakpoint (0x%s): Error: %s\n",
2386
                              saddr,
2387
                              err->string);
2388
          return 1;
2389
        }
2390
    }
2391
  fprintf_unfiltered (gdb_stderr, "\
2392
mips_common_breakpoint (0x%s): Unknown error: 0x%x\n",
2393
                      saddr,
2394
                      rerrflg);
2395
  return 1;
2396
}
2397
 
2398
 
2399
/* This routine sends a breakpoint command to the remote target.
2400
 
2401
   <SET> is 1 if setting a breakpoint, or 0 if clearing a breakpoint.
2402
   <ADDR> is the address of the breakpoint.
2403
   <LEN> the length of the region to break on.
2404
   <TYPE> is the type of breakpoint:
2405
 
2406
   1 = read                     (BREAK_READ)
2407
   2 = read/write               (BREAK_ACCESS)
2408
   3 = instruction fetch        (BREAK_FETCH)
2409
 
2410
   Return 0 if successful; otherwise 1.  */
2411
 
2412
static int
2413
mips_common_breakpoint (int set, CORE_ADDR addr, int len, enum break_type type)
2414
{
2415
  char buf[DATA_MAXLEN + 1];
2416
  char cmd, rcmd;
2417
  int rpid, rerrflg, rresponse, rlen;
2418
  int nfields;
2419
 
2420
  addr = gdbarch_addr_bits_remove (current_gdbarch, addr);
2421
 
2422
  if (mips_monitor == MON_LSI)
2423
    {
2424
      if (set == 0)              /* clear breakpoint */
2425
        {
2426
          /* The LSI PMON "clear breakpoint" has this form:
2427
             <pid> 'b' <bptn> 0x0
2428
             reply:
2429
             <pid> 'b' 0x0 <code>
2430
 
2431
             <bptn> is a breakpoint number returned by an earlier 'B' command.
2432
             Possible return codes: OK, E_BPT.  */
2433
 
2434
          int i;
2435
 
2436
          /* Search for the breakpoint in the table.  */
2437
          for (i = 0; i < MAX_LSI_BREAKPOINTS; i++)
2438
            if (lsi_breakpoints[i].type == type
2439
                && lsi_breakpoints[i].addr == addr
2440
                && lsi_breakpoints[i].len == len)
2441
              break;
2442
 
2443
          /* Clear the table entry and tell PMON to clear the breakpoint.  */
2444
          if (i == MAX_LSI_BREAKPOINTS)
2445
            {
2446
              warning ("\
2447
mips_common_breakpoint: Attempt to clear bogus breakpoint at %s\n",
2448
                       paddr_nz (addr));
2449
              return 1;
2450
            }
2451
 
2452
          lsi_breakpoints[i].type = BREAK_UNUSED;
2453
          sprintf (buf, "0x0 b 0x%x 0x0", i);
2454
          mips_send_packet (buf, 1);
2455
 
2456
          rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2457
          buf[rlen] = '\0';
2458
 
2459
          nfields = sscanf (buf, "0x%x b 0x0 0x%x", &rpid, &rerrflg);
2460
          if (nfields != 2)
2461
            mips_error ("\
2462
mips_common_breakpoint: Bad response from remote board: %s",
2463
                        buf);
2464
 
2465
          return (mips_check_lsi_error (addr, rerrflg));
2466
        }
2467
      else
2468
        /* set a breakpoint */
2469
        {
2470
          /* The LSI PMON "set breakpoint" command has this form:
2471
             <pid> 'B' <addr> 0x0
2472
             reply:
2473
             <pid> 'B' <bptn> <code>
2474
 
2475
             The "set data breakpoint" command has this form:
2476
 
2477
             <pid> 'A' <addr1> <type> [<addr2>  [<value>]]
2478
 
2479
             where: type= "0x1" = read
2480
             "0x2" = write
2481
             "0x3" = access (read or write)
2482
 
2483
             The reply returns two values:
2484
             bptn - a breakpoint number, which is a small integer with
2485
             possible values of zero through 255.
2486
             code - an error return code, a value of zero indicates a
2487
             succesful completion, other values indicate various
2488
             errors and warnings.
2489
 
2490
             Possible return codes: OK, W_QAL, E_QAL, E_OUT, E_NON.
2491
 
2492
           */
2493
 
2494
          if (type == BREAK_FETCH)      /* instruction breakpoint */
2495
            {
2496
              cmd = 'B';
2497
              sprintf (buf, "0x0 B 0x%s 0x0", paddr_nz (addr));
2498
            }
2499
          else
2500
            /* watchpoint */
2501
            {
2502
              cmd = 'A';
2503
              sprintf (buf, "0x0 A 0x%s 0x%x 0x%s", paddr_nz (addr),
2504
                     type == BREAK_READ ? 1 : (type == BREAK_WRITE ? 2 : 3),
2505
                       paddr_nz (addr + len - 1));
2506
            }
2507
          mips_send_packet (buf, 1);
2508
 
2509
          rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2510
          buf[rlen] = '\0';
2511
 
2512
          nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
2513
                            &rpid, &rcmd, &rresponse, &rerrflg);
2514
          if (nfields != 4 || rcmd != cmd || rresponse > 255)
2515
            mips_error ("\
2516
mips_common_breakpoint: Bad response from remote board: %s",
2517
                        buf);
2518
 
2519
          if (rerrflg != 0)
2520
            if (mips_check_lsi_error (addr, rerrflg))
2521
              return 1;
2522
 
2523
          /* rresponse contains PMON's breakpoint number.  Record the
2524
             information for this breakpoint so we can clear it later.  */
2525
          lsi_breakpoints[rresponse].type = type;
2526
          lsi_breakpoints[rresponse].addr = addr;
2527
          lsi_breakpoints[rresponse].len = len;
2528
 
2529
          return 0;
2530
        }
2531
    }
2532
  else
2533
    {
2534
      /* On non-LSI targets, the breakpoint command has this form:
2535
         0x0 <CMD> <ADDR> <MASK> <FLAGS>
2536
         <MASK> is a don't care mask for addresses.
2537
         <FLAGS> is any combination of `r', `w', or `f' for read/write/fetch.
2538
       */
2539
      unsigned long mask;
2540
 
2541
      mask = calculate_mask (addr, len);
2542
      addr &= ~mask;
2543
 
2544
      if (set)                  /* set a breakpoint */
2545
        {
2546
          char *flags;
2547
          switch (type)
2548
            {
2549
            case BREAK_WRITE:   /* write */
2550
              flags = "w";
2551
              break;
2552
            case BREAK_READ:    /* read */
2553
              flags = "r";
2554
              break;
2555
            case BREAK_ACCESS:  /* read/write */
2556
              flags = "rw";
2557
              break;
2558
            case BREAK_FETCH:   /* fetch */
2559
              flags = "f";
2560
              break;
2561
            default:
2562
              internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
2563
            }
2564
 
2565
          cmd = 'B';
2566
          sprintf (buf, "0x0 B 0x%s 0x%s %s", paddr_nz (addr),
2567
                   paddr_nz (mask), flags);
2568
        }
2569
      else
2570
        {
2571
          cmd = 'b';
2572
          sprintf (buf, "0x0 b 0x%s", paddr_nz (addr));
2573
        }
2574
 
2575
      mips_send_packet (buf, 1);
2576
 
2577
      rlen = mips_receive_packet (buf, 1, mips_receive_wait);
2578
      buf[rlen] = '\0';
2579
 
2580
      nfields = sscanf (buf, "0x%x %c 0x%x 0x%x",
2581
                        &rpid, &rcmd, &rerrflg, &rresponse);
2582
 
2583
      if (nfields != 4 || rcmd != cmd)
2584
        mips_error ("\
2585
mips_common_breakpoint: Bad response from remote board: %s",
2586
                    buf);
2587
 
2588
      if (rerrflg != 0)
2589
        {
2590
          /* Ddb returns "0x0 b 0x16 0x0\000", whereas
2591
             Cogent returns "0x0 b 0xffffffff 0x16\000": */
2592
          if (mips_monitor == MON_DDB)
2593
            rresponse = rerrflg;
2594
          if (rresponse != 22)  /* invalid argument */
2595
            fprintf_unfiltered (gdb_stderr, "\
2596
mips_common_breakpoint (0x%s):  Got error: 0x%x\n",
2597
                                paddr_nz (addr), rresponse);
2598
          return 1;
2599
        }
2600
    }
2601
  return 0;
2602
}
2603
 
2604
static void
2605
send_srec (char *srec, int len, CORE_ADDR addr)
2606
{
2607
  while (1)
2608
    {
2609
      int ch;
2610
 
2611
      serial_write (mips_desc, srec, len);
2612
 
2613
      ch = mips_readchar (remote_timeout);
2614
 
2615
      switch (ch)
2616
        {
2617
        case SERIAL_TIMEOUT:
2618
          error ("Timeout during download.");
2619
          break;
2620
        case 0x6:               /* ACK */
2621
          return;
2622
        case 0x15:              /* NACK */
2623
          fprintf_unfiltered (gdb_stderr, "Download got a NACK at byte %s!  Retrying.\n", paddr_u (addr));
2624
          continue;
2625
        default:
2626
          error ("Download got unexpected ack char: 0x%x, retrying.\n", ch);
2627
        }
2628
    }
2629
}
2630
 
2631
/*  Download a binary file by converting it to S records. */
2632
 
2633
static void
2634
mips_load_srec (char *args)
2635
{
2636
  bfd *abfd;
2637
  asection *s;
2638
  char *buffer, srec[1024];
2639
  unsigned int i;
2640
  unsigned int srec_frame = 200;
2641
  int reclen;
2642
  static int hashmark = 1;
2643
 
2644
  buffer = alloca (srec_frame * 2 + 256);
2645
 
2646
  abfd = bfd_openr (args, 0);
2647
  if (!abfd)
2648
    {
2649
      printf_filtered ("Unable to open file %s\n", args);
2650
      return;
2651
    }
2652
 
2653
  if (bfd_check_format (abfd, bfd_object) == 0)
2654
    {
2655
      printf_filtered ("File is not an object file\n");
2656
      return;
2657
    }
2658
 
2659
/* This actually causes a download in the IDT binary format: */
2660
  mips_send_command (LOAD_CMD, 0);
2661
 
2662
  for (s = abfd->sections; s; s = s->next)
2663
    {
2664
      if (s->flags & SEC_LOAD)
2665
        {
2666
          unsigned int numbytes;
2667
 
2668
          /* FIXME!  vma too small????? */
2669
          printf_filtered ("%s\t: 0x%4lx .. 0x%4lx  ", s->name,
2670
                           (long) s->vma,
2671
                           (long) (s->vma + bfd_get_section_size (s)));
2672
          gdb_flush (gdb_stdout);
2673
 
2674
          for (i = 0; i < bfd_get_section_size (s); i += numbytes)
2675
            {
2676
              numbytes = min (srec_frame, bfd_get_section_size (s) - i);
2677
 
2678
              bfd_get_section_contents (abfd, s, buffer, i, numbytes);
2679
 
2680
              reclen = mips_make_srec (srec, '3', s->vma + i,
2681
                                       buffer, numbytes);
2682
              send_srec (srec, reclen, s->vma + i);
2683
 
2684
              if (deprecated_ui_load_progress_hook)
2685
                deprecated_ui_load_progress_hook (s->name, i);
2686
 
2687
              if (hashmark)
2688
                {
2689
                  putchar_unfiltered ('#');
2690
                  gdb_flush (gdb_stdout);
2691
                }
2692
 
2693
            }                   /* Per-packet (or S-record) loop */
2694
 
2695
          putchar_unfiltered ('\n');
2696
        }                       /* Loadable sections */
2697
    }
2698
  if (hashmark)
2699
    putchar_unfiltered ('\n');
2700
 
2701
  /* Write a type 7 terminator record. no data for a type 7, and there
2702
     is no data, so len is 0.  */
2703
 
2704
  reclen = mips_make_srec (srec, '7', abfd->start_address, NULL, 0);
2705
 
2706
  send_srec (srec, reclen, abfd->start_address);
2707
 
2708
  serial_flush_input (mips_desc);
2709
}
2710
 
2711
/*
2712
 * mips_make_srec -- make an srecord. This writes each line, one at a
2713
 *      time, each with it's own header and trailer line.
2714
 *      An srecord looks like this:
2715
 *
2716
 * byte count-+     address
2717
 * start ---+ |        |       data        +- checksum
2718
 *          | |        |                   |
2719
 *        S01000006F6B692D746573742E73726563E4
2720
 *        S315000448600000000000000000FC00005900000000E9
2721
 *        S31A0004000023C1400037DE00F023604000377B009020825000348D
2722
 *        S30B0004485A0000000000004E
2723
 *        S70500040000F6
2724
 *
2725
 *      S<type><length><address><data><checksum>
2726
 *
2727
 *      Where
2728
 *      - length
2729
 *        is the number of bytes following upto the checksum. Note that
2730
 *        this is not the number of chars following, since it takes two
2731
 *        chars to represent a byte.
2732
 *      - type
2733
 *        is one of:
2734
 *        0) header record
2735
 *        1) two byte address data record
2736
 *        2) three byte address data record
2737
 *        3) four byte address data record
2738
 *        7) four byte address termination record
2739
 *        8) three byte address termination record
2740
 *        9) two byte address termination record
2741
 *
2742
 *      - address
2743
 *        is the start address of the data following, or in the case of
2744
 *        a termination record, the start address of the image
2745
 *      - data
2746
 *        is the data.
2747
 *      - checksum
2748
 *        is the sum of all the raw byte data in the record, from the length
2749
 *        upwards, modulo 256 and subtracted from 255.
2750
 *
2751
 * This routine returns the length of the S-record.
2752
 *
2753
 */
2754
 
2755
static int
2756
mips_make_srec (char *buf, int type, CORE_ADDR memaddr, unsigned char *myaddr,
2757
                int len)
2758
{
2759
  unsigned char checksum;
2760
  int i;
2761
 
2762
  /* Create the header for the srec. addr_size is the number of bytes in the address,
2763
     and 1 is the number of bytes in the count.  */
2764
 
2765
  /* FIXME!! bigger buf required for 64-bit! */
2766
  buf[0] = 'S';
2767
  buf[1] = type;
2768
  buf[2] = len + 4 + 1;         /* len + 4 byte address + 1 byte checksum */
2769
  /* This assumes S3 style downloads (4byte addresses). There should
2770
     probably be a check, or the code changed to make it more
2771
     explicit. */
2772
  buf[3] = memaddr >> 24;
2773
  buf[4] = memaddr >> 16;
2774
  buf[5] = memaddr >> 8;
2775
  buf[6] = memaddr;
2776
  memcpy (&buf[7], myaddr, len);
2777
 
2778
  /* Note that the checksum is calculated on the raw data, not the
2779
     hexified data.  It includes the length, address and the data
2780
     portions of the packet.  */
2781
  checksum = 0;
2782
  buf += 2;                     /* Point at length byte */
2783
  for (i = 0; i < len + 4 + 1; i++)
2784
    checksum += *buf++;
2785
 
2786
  *buf = ~checksum;
2787
 
2788
  return len + 8;
2789
}
2790
 
2791
/* The following manifest controls whether we enable the simple flow
2792
   control support provided by the monitor. If enabled the code will
2793
   wait for an affirmative ACK between transmitting packets. */
2794
#define DOETXACK (1)
2795
 
2796
/* The PMON fast-download uses an encoded packet format constructed of
2797
   3byte data packets (encoded as 4 printable ASCII characters), and
2798
   escape sequences (preceded by a '/'):
2799
 
2800
   'K'     clear checksum
2801
   'C'     compare checksum (12bit value, not included in checksum calculation)
2802
   'S'     define symbol name (for addr) terminated with "," and padded to 4char boundary
2803
   'Z'     zero fill multiple of 3bytes
2804
   'B'     byte (12bit encoded value, of 8bit data)
2805
   'A'     address (36bit encoded value)
2806
   'E'     define entry as original address, and exit load
2807
 
2808
   The packets are processed in 4 character chunks, so the escape
2809
   sequences that do not have any data (or variable length data)
2810
   should be padded to a 4 character boundary.  The decoder will give
2811
   an error if the complete message block size is not a multiple of
2812
   4bytes (size of record).
2813
 
2814
   The encoding of numbers is done in 6bit fields.  The 6bit value is
2815
   used to index into this string to get the specific character
2816
   encoding for the value: */
2817
static char encoding[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789,.";
2818
 
2819
/* Convert the number of bits required into an encoded number, 6bits
2820
   at a time (range 0..63).  Keep a checksum if required (passed
2821
   pointer non-NULL). The function returns the number of encoded
2822
   characters written into the buffer. */
2823
static int
2824
pmon_makeb64 (unsigned long v, char *p, int n, int *chksum)
2825
{
2826
  int count = (n / 6);
2827
 
2828
  if ((n % 12) != 0)
2829
    {
2830
      fprintf_unfiltered (gdb_stderr,
2831
                          "Fast encoding bitcount must be a multiple of 12bits: %dbit%s\n", n, (n == 1) ? "" : "s");
2832
      return (0);
2833
    }
2834
  if (n > 36)
2835
    {
2836
      fprintf_unfiltered (gdb_stderr,
2837
                          "Fast encoding cannot process more than 36bits at the moment: %dbits\n", n);
2838
      return (0);
2839
    }
2840
 
2841
  /* Deal with the checksum: */
2842
  if (chksum != NULL)
2843
    {
2844
      switch (n)
2845
        {
2846
        case 36:
2847
          *chksum += ((v >> 24) & 0xFFF);
2848
        case 24:
2849
          *chksum += ((v >> 12) & 0xFFF);
2850
        case 12:
2851
          *chksum += ((v >> 0) & 0xFFF);
2852
        }
2853
    }
2854
 
2855
  do
2856
    {
2857
      n -= 6;
2858
      *p++ = encoding[(v >> n) & 0x3F];
2859
    }
2860
  while (n > 0);
2861
 
2862
  return (count);
2863
}
2864
 
2865
/* Shorthand function (that could be in-lined) to output the zero-fill
2866
   escape sequence into the data stream. */
2867
static int
2868
pmon_zeroset (int recsize, char **buff, int *amount, unsigned int *chksum)
2869
{
2870
  int count;
2871
 
2872
  sprintf (*buff, "/Z");
2873
  count = pmon_makeb64 (*amount, (*buff + 2), 12, chksum);
2874
  *buff += (count + 2);
2875
  *amount = 0;
2876
  return (recsize + count + 2);
2877
}
2878
 
2879
static int
2880
pmon_checkset (int recsize, char **buff, int *value)
2881
{
2882
  int count;
2883
 
2884
  /* Add the checksum (without updating the value): */
2885
  sprintf (*buff, "/C");
2886
  count = pmon_makeb64 (*value, (*buff + 2), 12, NULL);
2887
  *buff += (count + 2);
2888
  sprintf (*buff, "\n");
2889
  *buff += 2;                   /* include zero terminator */
2890
  /* Forcing a checksum validation clears the sum: */
2891
  *value = 0;
2892
  return (recsize + count + 3);
2893
}
2894
 
2895
/* Amount of padding we leave after at the end of the output buffer,
2896
   for the checksum and line termination characters: */
2897
#define CHECKSIZE (4 + 4 + 4 + 2)
2898
/* zero-fill, checksum, transfer end and line termination space. */
2899
 
2900
/* The amount of binary data loaded from the object file in a single
2901
   operation: */
2902
#define BINCHUNK (1024)
2903
 
2904
/* Maximum line of data accepted by the monitor: */
2905
#define MAXRECSIZE (550)
2906
/* NOTE: This constant depends on the monitor being used. This value
2907
   is for PMON 5.x on the Cogent Vr4300 board. */
2908
 
2909
static void
2910
pmon_make_fastrec (char **outbuf, unsigned char *inbuf, int *inptr,
2911
                   int inamount, int *recsize, unsigned int *csum,
2912
                   unsigned int *zerofill)
2913
{
2914
  int count = 0;
2915
  char *p = *outbuf;
2916
 
2917
  /* This is a simple check to ensure that our data will fit within
2918
     the maximum allowable record size. Each record output is 4bytes
2919
     in length. We must allow space for a pending zero fill command,
2920
     the record, and a checksum record. */
2921
  while ((*recsize < (MAXRECSIZE - CHECKSIZE)) && ((inamount - *inptr) > 0))
2922
    {
2923
      /* Process the binary data: */
2924
      if ((inamount - *inptr) < 3)
2925
        {
2926
          if (*zerofill != 0)
2927
            *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2928
          sprintf (p, "/B");
2929
          count = pmon_makeb64 (inbuf[*inptr], &p[2], 12, csum);
2930
          p += (2 + count);
2931
          *recsize += (2 + count);
2932
          (*inptr)++;
2933
        }
2934
      else
2935
        {
2936
          unsigned int value = ((inbuf[*inptr + 0] << 16) | (inbuf[*inptr + 1] << 8) | inbuf[*inptr + 2]);
2937
          /* Simple check for zero data. TODO: A better check would be
2938
             to check the last, and then the middle byte for being zero
2939
             (if the first byte is not). We could then check for
2940
             following runs of zeros, and if above a certain size it is
2941
             worth the 4 or 8 character hit of the byte insertions used
2942
             to pad to the start of the zeroes. NOTE: This also depends
2943
             on the alignment at the end of the zero run. */
2944
          if (value == 0x00000000)
2945
            {
2946
              (*zerofill)++;
2947
              if (*zerofill == 0xFFF)   /* 12bit counter */
2948
                *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2949
            }
2950
          else
2951
            {
2952
              if (*zerofill != 0)
2953
                *recsize = pmon_zeroset (*recsize, &p, zerofill, csum);
2954
              count = pmon_makeb64 (value, p, 24, csum);
2955
              p += count;
2956
              *recsize += count;
2957
            }
2958
          *inptr += 3;
2959
        }
2960
    }
2961
 
2962
  *outbuf = p;
2963
  return;
2964
}
2965
 
2966
static int
2967
pmon_check_ack (char *mesg)
2968
{
2969
#if defined(DOETXACK)
2970
  int c;
2971
 
2972
  if (!tftp_in_use)
2973
    {
2974
      c = serial_readchar (udp_in_use ? udp_desc : mips_desc,
2975
                           remote_timeout);
2976
      if ((c == SERIAL_TIMEOUT) || (c != 0x06))
2977
        {
2978
          fprintf_unfiltered (gdb_stderr,
2979
                              "Failed to receive valid ACK for %s\n", mesg);
2980
          return (-1);          /* terminate the download */
2981
        }
2982
    }
2983
#endif /* DOETXACK */
2984
  return (0);
2985
}
2986
 
2987
/* pmon_download - Send a sequence of characters to the PMON download port,
2988
   which is either a serial port or a UDP socket.  */
2989
 
2990
static void
2991
pmon_start_download (void)
2992
{
2993
  if (tftp_in_use)
2994
    {
2995
      /* Create the temporary download file.  */
2996
      if ((tftp_file = fopen (tftp_localname, "w")) == NULL)
2997
        perror_with_name (tftp_localname);
2998
    }
2999
  else
3000
    {
3001
      mips_send_command (udp_in_use ? LOAD_CMD_UDP : LOAD_CMD, 0);
3002
      mips_expect ("Downloading from ");
3003
      mips_expect (udp_in_use ? "udp" : "tty0");
3004
      mips_expect (", ^C to abort\r\n");
3005
    }
3006
}
3007
 
3008
static int
3009
mips_expect_download (char *string)
3010
{
3011
  if (!mips_expect (string))
3012
    {
3013
      fprintf_unfiltered (gdb_stderr, "Load did not complete successfully.\n");
3014
      if (tftp_in_use)
3015
        remove (tftp_localname);        /* Remove temporary file */
3016
      return 0;
3017
    }
3018
  else
3019
    return 1;
3020
}
3021
 
3022
static void
3023
pmon_check_entry_address (char *entry_address, int final)
3024
{
3025
  char hexnumber[9];            /* includes '\0' space */
3026
  mips_expect_timeout (entry_address, tftp_in_use ? 15 : remote_timeout);
3027
  sprintf (hexnumber, "%x", final);
3028
  mips_expect (hexnumber);
3029
  mips_expect ("\r\n");
3030
}
3031
 
3032
static int
3033
pmon_check_total (int bintotal)
3034
{
3035
  char hexnumber[9];            /* includes '\0' space */
3036
  mips_expect ("\r\ntotal = 0x");
3037
  sprintf (hexnumber, "%x", bintotal);
3038
  mips_expect (hexnumber);
3039
  return mips_expect_download (" bytes\r\n");
3040
}
3041
 
3042
static void
3043
pmon_end_download (int final, int bintotal)
3044
{
3045
  char hexnumber[9];            /* includes '\0' space */
3046
 
3047
  if (tftp_in_use)
3048
    {
3049
      static char *load_cmd_prefix = "load -b -s ";
3050
      char *cmd;
3051
      struct stat stbuf;
3052
 
3053
      /* Close off the temporary file containing the load data.  */
3054
      fclose (tftp_file);
3055
      tftp_file = NULL;
3056
 
3057
      /* Make the temporary file readable by the world.  */
3058
      if (stat (tftp_localname, &stbuf) == 0)
3059
        chmod (tftp_localname, stbuf.st_mode | S_IROTH);
3060
 
3061
      /* Must reinitialize the board to prevent PMON from crashing.  */
3062
      mips_send_command ("initEther\r", -1);
3063
 
3064
      /* Send the load command.  */
3065
      cmd = xmalloc (strlen (load_cmd_prefix) + strlen (tftp_name) + 2);
3066
      strcpy (cmd, load_cmd_prefix);
3067
      strcat (cmd, tftp_name);
3068
      strcat (cmd, "\r");
3069
      mips_send_command (cmd, 0);
3070
      xfree (cmd);
3071
      if (!mips_expect_download ("Downloading from "))
3072
        return;
3073
      if (!mips_expect_download (tftp_name))
3074
        return;
3075
      if (!mips_expect_download (", ^C to abort\r\n"))
3076
        return;
3077
    }
3078
 
3079
  /* Wait for the stuff that PMON prints after the load has completed.
3080
     The timeout value for use in the tftp case (15 seconds) was picked
3081
     arbitrarily but might be too small for really large downloads. FIXME. */
3082
  switch (mips_monitor)
3083
    {
3084
    case MON_LSI:
3085
      pmon_check_ack ("termination");
3086
      pmon_check_entry_address ("Entry address is ", final);
3087
      if (!pmon_check_total (bintotal))
3088
        return;
3089
      break;
3090
    default:
3091
      pmon_check_entry_address ("Entry Address  = ", final);
3092
      pmon_check_ack ("termination");
3093
      if (!pmon_check_total (bintotal))
3094
        return;
3095
      break;
3096
    }
3097
 
3098
  if (tftp_in_use)
3099
    remove (tftp_localname);    /* Remove temporary file */
3100
}
3101
 
3102
static void
3103
pmon_download (char *buffer, int length)
3104
{
3105
  if (tftp_in_use)
3106
    fwrite (buffer, 1, length, tftp_file);
3107
  else
3108
    serial_write (udp_in_use ? udp_desc : mips_desc, buffer, length);
3109
}
3110
 
3111
static void
3112
pmon_load_fast (char *file)
3113
{
3114
  bfd *abfd;
3115
  asection *s;
3116
  unsigned char *binbuf;
3117
  char *buffer;
3118
  int reclen;
3119
  unsigned int csum = 0;
3120
  int hashmark = !tftp_in_use;
3121
  int bintotal = 0;
3122
  int final = 0;
3123
  int finished = 0;
3124
 
3125
  buffer = (char *) xmalloc (MAXRECSIZE + 1);
3126
  binbuf = (unsigned char *) xmalloc (BINCHUNK);
3127
 
3128
  abfd = bfd_openr (file, 0);
3129
  if (!abfd)
3130
    {
3131
      printf_filtered ("Unable to open file %s\n", file);
3132
      return;
3133
    }
3134
 
3135
  if (bfd_check_format (abfd, bfd_object) == 0)
3136
    {
3137
      printf_filtered ("File is not an object file\n");
3138
      return;
3139
    }
3140
 
3141
  /* Setup the required download state: */
3142
  mips_send_command ("set dlproto etxack\r", -1);
3143
  mips_send_command ("set dlecho off\r", -1);
3144
  /* NOTE: We get a "cannot set variable" message if the variable is
3145
     already defined to have the argument we give. The code doesn't
3146
     care, since it just scans to the next prompt anyway. */
3147
  /* Start the download: */
3148
  pmon_start_download ();
3149
 
3150
  /* Zero the checksum */
3151
  sprintf (buffer, "/Kxx\n");
3152
  reclen = strlen (buffer);
3153
  pmon_download (buffer, reclen);
3154
  finished = pmon_check_ack ("/Kxx");
3155
 
3156
  for (s = abfd->sections; s && !finished; s = s->next)
3157
    if (s->flags & SEC_LOAD)    /* only deal with loadable sections */
3158
      {
3159
        bintotal += bfd_get_section_size (s);
3160
        final = (s->vma + bfd_get_section_size (s));
3161
 
3162
        printf_filtered ("%s\t: 0x%4x .. 0x%4x  ", s->name, (unsigned int) s->vma,
3163
                         (unsigned int) (s->vma + bfd_get_section_size (s)));
3164
        gdb_flush (gdb_stdout);
3165
 
3166
        /* Output the starting address */
3167
        sprintf (buffer, "/A");
3168
        reclen = pmon_makeb64 (s->vma, &buffer[2], 36, &csum);
3169
        buffer[2 + reclen] = '\n';
3170
        buffer[3 + reclen] = '\0';
3171
        reclen += 3;            /* for the initial escape code and carriage return */
3172
        pmon_download (buffer, reclen);
3173
        finished = pmon_check_ack ("/A");
3174
 
3175
        if (!finished)
3176
          {
3177
            unsigned int binamount;
3178
            unsigned int zerofill = 0;
3179
            char *bp = buffer;
3180
            unsigned int i;
3181
 
3182
            reclen = 0;
3183
 
3184
            for (i = 0;
3185
                 i < bfd_get_section_size (s) && !finished;
3186
                 i += binamount)
3187
              {
3188
                int binptr = 0;
3189
 
3190
                binamount = min (BINCHUNK, bfd_get_section_size (s) - i);
3191
 
3192
                bfd_get_section_contents (abfd, s, binbuf, i, binamount);
3193
 
3194
                /* This keeps a rolling checksum, until we decide to output
3195
                   the line: */
3196
                for (; ((binamount - binptr) > 0);)
3197
                  {
3198
                    pmon_make_fastrec (&bp, binbuf, &binptr, binamount,
3199
                                       &reclen, &csum, &zerofill);
3200
                    if (reclen >= (MAXRECSIZE - CHECKSIZE))
3201
                      {
3202
                        reclen = pmon_checkset (reclen, &bp, &csum);
3203
                        pmon_download (buffer, reclen);
3204
                        finished = pmon_check_ack ("data record");
3205
                        if (finished)
3206
                          {
3207
                            zerofill = 0;        /* do not transmit pending zerofills */
3208
                            break;
3209
                          }
3210
 
3211
                        if (deprecated_ui_load_progress_hook)
3212
                          deprecated_ui_load_progress_hook (s->name, i);
3213
 
3214
                        if (hashmark)
3215
                          {
3216
                            putchar_unfiltered ('#');
3217
                            gdb_flush (gdb_stdout);
3218
                          }
3219
 
3220
                        bp = buffer;
3221
                        reclen = 0;      /* buffer processed */
3222
                      }
3223
                  }
3224
              }
3225
 
3226
            /* Ensure no out-standing zerofill requests: */
3227
            if (zerofill != 0)
3228
              reclen = pmon_zeroset (reclen, &bp, &zerofill, &csum);
3229
 
3230
            /* and then flush the line: */
3231
            if (reclen > 0)
3232
              {
3233
                reclen = pmon_checkset (reclen, &bp, &csum);
3234
                /* Currently pmon_checkset outputs the line terminator by
3235
                   default, so we write out the buffer so far: */
3236
                pmon_download (buffer, reclen);
3237
                finished = pmon_check_ack ("record remnant");
3238
              }
3239
          }
3240
 
3241
        putchar_unfiltered ('\n');
3242
      }
3243
 
3244
  /* Terminate the transfer. We know that we have an empty output
3245
     buffer at this point. */
3246
  sprintf (buffer, "/E/E\n");   /* include dummy padding characters */
3247
  reclen = strlen (buffer);
3248
  pmon_download (buffer, reclen);
3249
 
3250
  if (finished)
3251
    {                           /* Ignore the termination message: */
3252
      serial_flush_input (udp_in_use ? udp_desc : mips_desc);
3253
    }
3254
  else
3255
    {                           /* Deal with termination message: */
3256
      pmon_end_download (final, bintotal);
3257
    }
3258
 
3259
  return;
3260
}
3261
 
3262
/* mips_load -- download a file. */
3263
 
3264
static void
3265
mips_load (char *file, int from_tty)
3266
{
3267
  /* Get the board out of remote debugging mode.  */
3268
  if (mips_exit_debug ())
3269
    error ("mips_load:  Couldn't get into monitor mode.");
3270
 
3271
  if (mips_monitor != MON_IDT)
3272
    pmon_load_fast (file);
3273
  else
3274
    mips_load_srec (file);
3275
 
3276
  mips_initialize ();
3277
 
3278
  /* Finally, make the PC point at the start address */
3279
  if (mips_monitor != MON_IDT)
3280
    {
3281
      /* Work around problem where PMON monitor updates the PC after a load
3282
         to a different value than GDB thinks it has. The following ensures
3283
         that the write_pc() WILL update the PC value: */
3284
      regcache_set_valid_p (get_current_regcache (),
3285
                            gdbarch_pc_regnum (current_gdbarch), 0);
3286
    }
3287
  if (exec_bfd)
3288
    write_pc (bfd_get_start_address (exec_bfd));
3289
 
3290
  inferior_ptid = null_ptid;    /* No process now */
3291
 
3292
/* This is necessary because many things were based on the PC at the time that
3293
   we attached to the monitor, which is no longer valid now that we have loaded
3294
   new code (and just changed the PC).  Another way to do this might be to call
3295
   normal_stop, except that the stack may not be valid, and things would get
3296
   horribly confused... */
3297
 
3298
  clear_symtab_users ();
3299
}
3300
 
3301
 
3302
/* Pass the command argument as a packet to PMON verbatim.  */
3303
 
3304
static void
3305
pmon_command (char *args, int from_tty)
3306
{
3307
  char buf[DATA_MAXLEN + 1];
3308
  int rlen;
3309
 
3310
  sprintf (buf, "0x0 %s", args);
3311
  mips_send_packet (buf, 1);
3312
  printf_filtered ("Send packet: %s\n", buf);
3313
 
3314
  rlen = mips_receive_packet (buf, 1, mips_receive_wait);
3315
  buf[rlen] = '\0';
3316
  printf_filtered ("Received packet: %s\n", buf);
3317
}
3318
 
3319
extern initialize_file_ftype _initialize_remote_mips; /* -Wmissing-prototypes */
3320
 
3321
void
3322
_initialize_remote_mips (void)
3323
{
3324
  /* Initialize the fields in mips_ops that are common to all four targets.  */
3325
  mips_ops.to_longname = "Remote MIPS debugging over serial line";
3326
  mips_ops.to_close = mips_close;
3327
  mips_ops.to_detach = mips_detach;
3328
  mips_ops.to_resume = mips_resume;
3329
  mips_ops.to_fetch_registers = mips_fetch_registers;
3330
  mips_ops.to_store_registers = mips_store_registers;
3331
  mips_ops.to_prepare_to_store = mips_prepare_to_store;
3332
  mips_ops.deprecated_xfer_memory = mips_xfer_memory;
3333
  mips_ops.to_files_info = mips_files_info;
3334
  mips_ops.to_insert_breakpoint = mips_insert_breakpoint;
3335
  mips_ops.to_remove_breakpoint = mips_remove_breakpoint;
3336
  mips_ops.to_insert_watchpoint = mips_insert_watchpoint;
3337
  mips_ops.to_remove_watchpoint = mips_remove_watchpoint;
3338
  mips_ops.to_stopped_by_watchpoint = mips_stopped_by_watchpoint;
3339
  mips_ops.to_can_use_hw_breakpoint = mips_can_use_watchpoint;
3340
  mips_ops.to_kill = mips_kill;
3341
  mips_ops.to_load = mips_load;
3342
  mips_ops.to_create_inferior = mips_create_inferior;
3343
  mips_ops.to_mourn_inferior = mips_mourn_inferior;
3344
  mips_ops.to_log_command = serial_log_command;
3345
  mips_ops.to_stratum = process_stratum;
3346
  mips_ops.to_has_all_memory = 1;
3347
  mips_ops.to_has_memory = 1;
3348
  mips_ops.to_has_stack = 1;
3349
  mips_ops.to_has_registers = 1;
3350
  mips_ops.to_has_execution = 1;
3351
  mips_ops.to_magic = OPS_MAGIC;
3352
 
3353
  /* Copy the common fields to all four target vectors.  */
3354
  pmon_ops = ddb_ops = lsi_ops = mips_ops;
3355
 
3356
  /* Initialize target-specific fields in the target vectors.  */
3357
  mips_ops.to_shortname = "mips";
3358
  mips_ops.to_doc = "\
3359
Debug a board using the MIPS remote debugging protocol over a serial line.\n\
3360
The argument is the device it is connected to or, if it contains a colon,\n\
3361
HOST:PORT to access a board over a network";
3362
  mips_ops.to_open = mips_open;
3363
  mips_ops.to_wait = mips_wait;
3364
 
3365
  pmon_ops.to_shortname = "pmon";
3366
  pmon_ops.to_doc = "\
3367
Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3368
line. The argument is the device it is connected to or, if it contains a\n\
3369
colon, HOST:PORT to access a board over a network";
3370
  pmon_ops.to_open = pmon_open;
3371
  pmon_ops.to_wait = mips_wait;
3372
 
3373
  ddb_ops.to_shortname = "ddb";
3374
  ddb_ops.to_doc = "\
3375
Debug a board using the PMON MIPS remote debugging protocol over a serial\n\
3376
line. The first argument is the device it is connected to or, if it contains\n\
3377
a colon, HOST:PORT to access a board over a network.  The optional second\n\
3378
parameter is the temporary file in the form HOST:FILENAME to be used for\n\
3379
TFTP downloads to the board.  The optional third parameter is the local name\n\
3380
of the TFTP temporary file, if it differs from the filename seen by the board.";
3381
  ddb_ops.to_open = ddb_open;
3382
  ddb_ops.to_wait = mips_wait;
3383
 
3384
  lsi_ops.to_shortname = "lsi";
3385
  lsi_ops.to_doc = pmon_ops.to_doc;
3386
  lsi_ops.to_open = lsi_open;
3387
  lsi_ops.to_wait = mips_wait;
3388
 
3389
  /* Add the targets.  */
3390
  add_target (&mips_ops);
3391
  add_target (&pmon_ops);
3392
  add_target (&ddb_ops);
3393
  add_target (&lsi_ops);
3394
 
3395
  add_setshow_zinteger_cmd ("timeout", no_class, &mips_receive_wait, _("\
3396
Set timeout in seconds for remote MIPS serial I/O."), _("\
3397
Show timeout in seconds for remote MIPS serial I/O."), NULL,
3398
                            NULL,
3399
                            NULL, /* FIXME: i18n: */
3400
                            &setlist, &showlist);
3401
 
3402
  add_setshow_zinteger_cmd ("retransmit-timeout", no_class,
3403
                            &mips_retransmit_wait, _("\
3404
Set retransmit timeout in seconds for remote MIPS serial I/O."), _("\
3405
Show retransmit timeout in seconds for remote MIPS serial I/O."), _("\
3406
This is the number of seconds to wait for an acknowledgement to a packet\n\
3407
before resending the packet."),
3408
                            NULL,
3409
                            NULL, /* FIXME: i18n: */
3410
                            &setlist, &showlist);
3411
 
3412
  add_setshow_zinteger_cmd ("syn-garbage-limit", no_class,
3413
                            &mips_syn_garbage,  _("\
3414
Set the maximum number of characters to ignore when scanning for a SYN."), _("\
3415
Show the maximum number of characters to ignore when scanning for a SYN."), _("\
3416
This is the maximum number of characters GDB will ignore when trying to\n\
3417
synchronize with the remote system.  A value of -1 means that there is no\n\
3418
limit. (Note that these characters are printed out even though they are\n\
3419
ignored.)"),
3420
                            NULL,
3421
                            NULL, /* FIXME: i18n: */
3422
                            &setlist, &showlist);
3423
 
3424
  add_setshow_string_cmd ("monitor-prompt", class_obscure,
3425
                          &mips_monitor_prompt, _("\
3426
Set the prompt that GDB expects from the monitor."), _("\
3427
Show the prompt that GDB expects from the monitor."), NULL,
3428
                          NULL,
3429
                          NULL, /* FIXME: i18n: */
3430
                          &setlist, &showlist);
3431
 
3432
  add_setshow_zinteger_cmd ("monitor-warnings", class_obscure,
3433
                            &monitor_warnings, _("\
3434
Set printing of monitor warnings."), _("\
3435
Show printing of monitor warnings."), _("\
3436
When enabled, monitor warnings about hardware breakpoints will be displayed."),
3437
                            NULL,
3438
                            NULL, /* FIXME: i18n: */
3439
                            &setlist, &showlist);
3440
 
3441
  add_com ("pmon", class_obscure, pmon_command,
3442
           _("Send a packet to PMON (must be in debug mode)."));
3443
 
3444
  add_setshow_boolean_cmd ("mask-address", no_class, &mask_address_p, _("\
3445
Set zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets."), _("\
3446
Show zeroing of upper 32 bits of 64-bit addresses when talking to PMON targets."), _("\
3447
Use \"on\" to enable the masking and \"off\" to disable it."),
3448
                           NULL,
3449
                           NULL, /* FIXME: i18n: */
3450
                           &setlist, &showlist);
3451
}

powered by: WebSVN 2.1.0

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