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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [remote-mips.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

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