1 /* Remote debugging interface for Densan DVE-R3900 ROM monitor for
3 Copyright 1997 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
28 #include "gdb_string.h"
31 /* Packet escape character used by Densan monitor. */
35 /* Maximum packet size. This is actually smaller than necessary
40 /* External functions. */
42 extern void report_transfer_performance
PARAMS ((unsigned long,
45 /* Certain registers are "bitmapped", in that the monitor can only display
46 them or let the user modify them as a series of named bitfields.
47 This structure describes a field in a bitmapped register. */
51 char *prefix
; /* string appearing before the value */
52 char *suffix
; /* string appearing after the value */
53 char *user_name
; /* name used by human when entering field value */
54 int length
; /* number of bits in the field */
55 int start
; /* starting (least significant) bit number of field */
58 /* Local functions for register manipulation. */
60 static void r3900_supply_register
PARAMS ((char *regname
, int regnamelen
,
61 char *val
, int vallen
));
62 static void fetch_bad_vaddr
PARAMS ((void));
63 static unsigned long fetch_fields
PARAMS ((struct bit_field
*bf
));
64 static void fetch_bitmapped_register
PARAMS ((int regno
,
65 struct bit_field
*bf
));
66 static void r3900_fetch_registers
PARAMS ((int regno
));
67 static void store_bitmapped_register
PARAMS ((int regno
,
68 struct bit_field
*bf
));
69 static void r3900_store_registers
PARAMS ((int regno
));
71 /* Local functions for fast binary loading. */
73 static void write_long
PARAMS ((char *buf
, long n
));
74 static void write_long_le
PARAMS ((char *buf
, long n
));
75 static int debug_readchar
PARAMS ((int hex
));
76 static void debug_write
PARAMS ((unsigned char *buf
, int buflen
));
77 static void ignore_packet
PARAMS ((void));
78 static void send_packet
PARAMS ((char type
, unsigned char *buf
, int buflen
,
80 static void process_read_request
PARAMS ((unsigned char *buf
, int buflen
));
81 static void count_section
PARAMS ((bfd
*abfd
, asection
*s
,
82 unsigned int *section_count
));
83 static void load_section
PARAMS ((bfd
*abfd
, asection
*s
,
84 unsigned int *data_count
));
85 static void r3900_load
PARAMS ((char *filename
, int from_tty
));
87 /* Miscellaneous local functions. */
89 static void r3900_open
PARAMS ((char *args
, int from_tty
));
92 /* Pointers to static functions in monitor.c for fetching and storing
93 registers. We can't use these function in certain cases where the Densan
94 monitor acts perversely: for registers that it displays in bit-map
95 format, and those that can't be modified at all. In those cases
96 we have to use our own functions to fetch and store their values. */
98 static void (*orig_monitor_fetch_registers
) PARAMS ((int regno
));
99 static void (*orig_monitor_store_registers
) PARAMS ((int regno
));
101 /* Pointer to static function in monitor. for loading programs.
102 We use this function for loading S-records via the serial link. */
104 static void (*orig_monitor_load
) PARAMS ((char *file
, int from_tty
));
106 /* This flag is set if a fast ethernet download should be used. */
108 static int ethernet
= 0;
110 /* This array of registers needs to match the indexes used by GDB. The
111 whole reason this exists is because the various ROM monitors use
112 different names than GDB does, and don't support all the registers
115 static char *r3900_regnames
[NUM_REGS
] =
117 "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",
118 "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
119 "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
120 "r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31",
125 "B", /* BADVADDR_REGNUM */
126 "Pcause", /* CAUSE_REGNUM */
131 /* Table of register names produced by monitor's register dump command. */
133 static struct reg_entry
139 { "r0_zero", 0 }, { "r1_at", 1 }, { "r2_v0", 2 }, { "r3_v1", 3 },
140 { "r4_a0", 4 }, { "r5_a1", 5 }, { "r6_a2", 6 }, { "r7_a3", 7 },
141 { "r8_t0", 8 }, { "r9_t1", 9 }, { "r10_t2", 10 }, { "r11_t3", 11 },
142 { "r12_t4", 12 }, { "r13_t5", 13 }, { "r14_t6", 14 }, { "r15_t7", 15 },
143 { "r16_s0", 16 }, { "r17_s1", 17 }, { "r18_s2", 18 }, { "r19_s3", 19 },
144 { "r20_s4", 20 }, { "r21_s5", 21 }, { "r22_s6", 22 }, { "r23_s7", 23 },
145 { "r24_t8", 24 }, { "r25_t9", 25 }, { "r26_k0", 26 }, { "r27_k1", 27 },
146 { "r28_gp", 28 }, { "r29_sp", 29 }, { "r30_fp", 30 }, { "r31_ra", 31 },
150 { "BadV", BADVADDR_REGNUM
},
155 /* The monitor displays the cache register along with the status register,
156 as if they were a single register. So when we want to fetch the
157 status register, parse but otherwise ignore the fields of the
158 cache register that the monitor displays. Register fields that should
159 be ignored have a length of zero in the tables below. */
161 static struct bit_field status_fields
[] =
163 /* Status register portion */
164 { "SR[<CU=", " ", "cu", 4, 28 },
165 { "RE=", " ", "re", 1, 25 },
166 { "BEV=", " ", "bev", 1, 22 },
167 { "TS=", " ", "ts", 1, 21 },
168 { "Nmi=", " ", "nmi", 1, 20 },
169 { "INT=", " ", "int", 6, 10 },
170 { "SW=", ">]", "sw", 2, 8 },
171 { "[<KUO=", " ", "kuo", 1, 5 },
172 { "IEO=", " ", "ieo", 1, 4 },
173 { "KUP=", " ", "kup", 1, 3 },
174 { "IEP=", " ", "iep", 1, 2 },
175 { "KUC=", " ", "kuc", 1, 1 },
176 { "IEC=", ">]", "iec", 1, 0 },
178 /* Cache register portion (dummy for parsing only) */
179 { "CR[<IalO="," ", "ialo", 0, 13 },
180 { "DalO=", " ", "dalo", 0, 12 },
181 { "IalP=", " ", "ialp", 0, 11 },
182 { "DalP=", " ", "dalp", 0, 10 },
183 { "IalC=", " ", "ialc", 0, 9 },
184 { "DalC=", ">] ", "dalc", 0, 8 },
186 { NULL
, NULL
, 0, 0 } /* end of table marker */
190 static struct bit_field cache_fields
[] =
192 /* Status register portion (dummy for parsing only) */
193 { "SR[<CU=", " ", "cu", 0, 28 },
194 { "RE=", " ", "re", 0, 25 },
195 { "BEV=", " ", "bev", 0, 22 },
196 { "TS=", " ", "ts", 0, 21 },
197 { "Nmi=", " ", "nmi", 0, 20 },
198 { "INT=", " ", "int", 0, 10 },
199 { "SW=", ">]", "sw", 0, 8 },
200 { "[<KUO=", " ", "kuo", 0, 5 },
201 { "IEO=", " ", "ieo", 0, 4 },
202 { "KUP=", " ", "kup", 0, 3 },
203 { "IEP=", " ", "iep", 0, 2 },
204 { "KUC=", " ", "kuc", 0, 1 },
205 { "IEC=", ">]", "iec", 0, 0 },
207 /* Cache register portion */
208 { "CR[<IalO="," ", "ialo", 1, 13 },
209 { "DalO=", " ", "dalo", 1, 12 },
210 { "IalP=", " ", "ialp", 1, 11 },
211 { "DalP=", " ", "dalp", 1, 10 },
212 { "IalC=", " ", "ialc", 1, 9 },
213 { "DalC=", ">] ", "dalc", 1, 8 },
215 { NULL
, NULL
, NULL
, 0, 0 } /* end of table marker */
218 static struct bit_field cause_fields
[] =
220 { "<BD=", " ", "bd", 1, 31 },
221 { "CE=", " ", "ce", 2, 28 },
222 { "IP=", " ", "ip", 6, 10 },
223 { "SW=", " ", "sw", 2, 8 },
224 { "EC=", ">]" , "ec", 5, 2 },
226 { NULL
, NULL
, NULL
, 0, 0 } /* end of table marker */
230 /* The monitor prints register values in the form
234 We look up the register name in a table, and remove the embedded space in
235 the hex value before passing it to monitor_supply_register. */
238 r3900_supply_register (regname
, regnamelen
, val
, vallen
)
249 /* Perform some sanity checks on the register name and value. */
250 if (regnamelen
< 2 || regnamelen
> 7 || vallen
!= 9)
253 /* Look up the register name. */
254 for (i
= 0; reg_table
[i
].name
!= NULL
; i
++)
256 int rlen
= strlen (reg_table
[i
].name
);
257 if (rlen
== regnamelen
&& strncmp (regname
, reg_table
[i
].name
, rlen
) == 0)
259 regno
= reg_table
[i
].regno
;
266 /* Copy the hex value to a buffer and eliminate the embedded space. */
267 for (i
= 0, p
= valbuf
; i
< vallen
; i
++)
272 monitor_supply_register (regno
, valbuf
);
275 /* Fetch the BadVaddr register. Unlike the other registers, this
276 one can't be modified, and the monitor won't even prompt to let
284 monitor_printf ("xB\r");
285 monitor_expect ("BadV=", NULL
, 0);
286 monitor_expect_prompt (buf
, sizeof(buf
));
287 monitor_supply_register (BADVADDR_REGNUM
, buf
);
291 /* Read a series of bit fields from the monitor, and return their
292 combined binary value. */
296 struct bit_field
*bf
;
299 unsigned long val
= 0;
302 for ( ; bf
->prefix
!= NULL
; bf
++)
304 monitor_expect (bf
->prefix
, NULL
, 0); /* get prefix */
305 monitor_expect (bf
->suffix
, buf
, sizeof (buf
)); /* hex value, suffix */
308 bits
= strtoul (buf
, NULL
, 16); /* get field value */
309 bits
&= ((1 << bf
->length
) - 1); /* mask out useless bits */
310 val
|= bits
<< bf
->start
; /* insert into register */
319 fetch_bitmapped_register (regno
, bf
)
321 struct bit_field
*bf
;
324 unsigned char regbuf
[MAX_REGISTER_RAW_SIZE
];
326 monitor_printf ("x%s\r", r3900_regnames
[regno
]);
327 val
= fetch_fields (bf
);
328 monitor_printf (".\r");
329 monitor_expect_prompt (NULL
, 0);
331 /* supply register stores in target byte order, so swap here */
333 store_unsigned_integer (regbuf
, REGISTER_RAW_SIZE (regno
), val
);
334 supply_register (regno
, regbuf
);
338 /* Fetch all registers (if regno is -1), or one register from the
339 monitor. For most registers, we can use the generic monitor_
340 monitor_fetch_registers function. But others are displayed in
341 very unusual fashion and must be handled specially. */
344 r3900_fetch_registers (regno
)
349 case BADVADDR_REGNUM
:
353 fetch_bitmapped_register (PS_REGNUM
, status_fields
);
356 fetch_bitmapped_register (CAUSE_REGNUM
, cause_fields
);
359 orig_monitor_fetch_registers (regno
);
364 /* Write the new value of the bitmapped register to the monitor. */
367 store_bitmapped_register (regno
, bf
)
369 struct bit_field
*bf
;
371 unsigned long oldval
, newval
;
373 /* Fetch the current value of the register. */
374 monitor_printf ("x%s\r", r3900_regnames
[regno
]);
375 oldval
= fetch_fields (bf
);
376 newval
= read_register (regno
);
378 /* To save time, write just the fields that have changed. */
379 for ( ; bf
->prefix
!= NULL
; bf
++)
383 unsigned long oldbits
, newbits
, mask
;
385 mask
= (1 << bf
->length
) - 1;
386 oldbits
= (oldval
>> bf
->start
) & mask
;
387 newbits
= (newval
>> bf
->start
) & mask
;
388 if (oldbits
!= newbits
)
389 monitor_printf ("%s %x ", bf
->user_name
, newbits
);
393 monitor_printf (".\r");
394 monitor_expect_prompt (NULL
, 0);
398 r3900_store_registers (regno
)
404 store_bitmapped_register (PS_REGNUM
, status_fields
);
407 store_bitmapped_register (CAUSE_REGNUM
, cause_fields
);
410 orig_monitor_store_registers (regno
);
415 /* Write a 4-byte integer to the buffer in big-endian order. */
422 buf
[0] = (n
>> 24) & 0xff;
423 buf
[1] = (n
>> 16) & 0xff;
424 buf
[2] = (n
>> 8) & 0xff;
429 /* Write a 4-byte integer to the buffer in little-endian order. */
432 write_long_le (buf
, n
)
437 buf
[1] = (n
>> 8) & 0xff;
438 buf
[2] = (n
>> 16) & 0xff;
439 buf
[3] = (n
>> 24) & 0xff;
443 /* Read a character from the monitor. If remote debugging is on,
444 print the received character. If HEX is non-zero, print the
445 character in hexadecimal; otherwise, print it in ascii. */
452 int c
= monitor_readchar ();
454 if (remote_debug
> 0)
457 sprintf (buf
, "[%02x]", c
& 0xff);
465 puts_debug ("Read -->", buf
, "<--");
471 /* Send a buffer of characters to the monitor. If remote debugging is on,
472 print the sent buffer in hex. */
475 debug_write (buf
, buflen
)
481 monitor_write (buf
, buflen
);
483 if (remote_debug
> 0)
487 sprintf (s
, "[%02x]", *buf
& 0xff);
488 puts_debug ("Sent -->", s
, "<--");
495 /* Ignore a packet sent to us by the monitor. It send packets
496 when its console is in "communications interface" mode. A packet
499 start of packet flag (one byte: 0xdc)
500 packet type (one byte)
512 /* Ignore lots of trash (messages about section addresses, for example)
513 until we see the start of a packet. */
514 for (len
= 0; len
< 256; len
++)
516 c
= debug_readchar (0);
521 error ("Packet header byte not found; %02x seen instead.", c
);
523 /* Read the packet type and length. */
524 c
= debug_readchar (1); /* type */
526 c
= debug_readchar (1); /* low byte of length */
529 c
= debug_readchar (1); /* high byte of length */
530 len
+= (c
& 0xff) << 8;
532 /* Ignore the rest of the packet. */
534 c
= debug_readchar (1);
538 /* Send a packet to the monitor. */
541 send_packet (type
, buf
, buflen
, seq
)
546 unsigned char hdr
[4];
550 /* If this is a 'p' packet, add one byte for a sequence number. */
554 /* If the buffer has a non-zero length, add two bytes for a checksum. */
558 /* Write the packet header. */
562 hdr
[3] = (len
>> 8) & 0xff;
563 debug_write (hdr
, sizeof (hdr
));
567 /* Write the packet data. */
568 debug_write (buf
, buflen
);
570 /* Write the sequence number if this is a 'p' packet. */
574 debug_write (hdr
, 1);
577 /* Write the checksum. */
579 for (i
= 0; i
< buflen
; i
++)
581 int tmp
= (buf
[i
] & 0xff);
592 sum
+= (seq
& 0xff) << 8;
594 sum
= (sum
& 0xffff) + ((sum
>> 16) & 0xffff);
595 sum
+= (sum
>> 16) & 1;
598 hdr
[0] = (sum
>> 8) & 0xff;
600 debug_write (hdr
, 2);
605 /* Respond to an expected read request from the monitor by sending
606 data in chunks. Handle all acknowledgements and handshaking packets. */
609 process_read_request (buf
, buflen
)
613 unsigned char len
[4];
617 /* Discard the read request. We have to hope it's for
618 the exact number of bytes we want to send. */
621 for (i
= chunk
= 0, seq
= 0; i
< buflen
; i
+= chunk
, seq
++)
623 /* Don't send more than 256 bytes at a time. */
625 if (chunk
> MAXPSIZE
)
628 /* Write a packet containing the number of bytes we are sending. */
629 write_long_le (len
, chunk
);
630 send_packet ('p', len
, sizeof (len
), seq
);
632 /* Write the data in raw form following the packet. */
633 debug_write (&buf
[i
], chunk
);
635 /* Discard the ACK packet. */
639 /* Send an "end of data" packet. */
640 send_packet ('e', "", 0, 0);
644 /* Count loadable sections (helper function for r3900_load). */
647 count_section (abfd
, s
, section_count
)
650 unsigned int *section_count
;
652 if (s
->flags
& SEC_LOAD
&& bfd_section_size (abfd
, s
) != 0)
657 /* Load a single BFD section (helper function for r3900_load).
659 WARNING: this code is filled with assumptions about how
660 the Densan monitor loads programs. The monitor issues
661 packets containing read requests, but rather than respond
662 to them in an general way, we expect them to following
665 For example, we know that the monitor will start loading by
666 issuing an 8-byte read request for the binary file header.
667 We know this is coming and ignore the actual contents
668 of the read request packet.
672 load_section (abfd
, s
, data_count
)
675 unsigned int *data_count
;
677 if (s
->flags
& SEC_LOAD
)
679 bfd_size_type section_size
= bfd_section_size (abfd
, s
);
680 bfd_vma section_base
= bfd_section_lma (abfd
, s
);
681 unsigned char *buffer
;
682 unsigned char header
[8];
684 /* Don't output zero-length sections. */
685 if (section_size
== 0)
688 *data_count
+= section_size
;
690 /* Print some fluff about the section being loaded. */
691 printf_filtered ("Loading section %s, size 0x%lx lma ",
692 bfd_section_name (abfd
, s
), (long)section_size
);
693 print_address_numeric (section_base
, 1, gdb_stdout
);
694 printf_filtered ("\n");
695 gdb_flush (gdb_stdout
);
697 /* Write the section header (location and size). */
698 write_long (&header
[0], (long)section_base
);
699 write_long (&header
[4], (long)section_size
);
700 process_read_request (header
, sizeof (header
));
702 /* Read the section contents into a buffer, write it out,
703 then free the buffer. */
704 buffer
= (unsigned char *) xmalloc (section_size
);
705 bfd_get_section_contents (abfd
, s
, buffer
, 0, section_size
);
706 process_read_request (buffer
, section_size
);
712 /* When the ethernet is used as the console port on the Densan board,
713 we can use the "Rm" command to do a fast binary load. The format
714 of the download data is:
716 number of sections (4 bytes)
717 starting address (4 bytes)
718 repeat for each section:
719 location address (4 bytes)
720 section size (4 bytes)
723 The 4-byte fields are all in big-endian order.
725 Using this command is tricky because we have to put the monitor
726 into a special funky "communications interface" mode, in which
727 it sends and receives packets of data along with the normal prompt.
731 r3900_load (filename
, from_tty
)
736 unsigned int data_count
= 0;
737 time_t start_time
, end_time
; /* for timing of download */
738 int section_count
= 0;
739 unsigned char buffer
[8];
741 /* If we are not using the ethernet, use the normal monitor load,
742 which sends S-records over the serial link. */
745 orig_monitor_load (filename
, from_tty
);
750 if (filename
== NULL
|| filename
[0] == 0)
751 filename
= get_exec_file (1);
752 abfd
= bfd_openr (filename
, 0);
754 error ("Unable to open file %s\n", filename
);
755 if (bfd_check_format (abfd
, bfd_object
) == 0)
756 error ("File is not an object file\n");
758 /* Output the "vconsi" command to get the monitor in the communication
759 state where it will accept a load command. This will cause
760 the monitor to emit a packet before each prompt, so ignore the packet. */
761 monitor_printf ("vconsi\r");
763 monitor_expect_prompt (NULL
, 0);
765 /* Output the "Rm" (load) command and respond to the subsequent "open"
766 packet by sending an ACK packet. */
767 monitor_printf ("Rm\r");
769 send_packet ('a', "", 0, 0);
771 /* Output the fast load header (number of sections and starting address). */
772 bfd_map_over_sections ((bfd
*) abfd
, count_section
, §ion_count
);
773 write_long (&buffer
[0], (long)section_count
);
775 write_long (&buffer
[4], (long)bfd_get_start_address (exec_bfd
));
777 write_long (&buffer
[4], 0);
778 process_read_request (buffer
, sizeof (buffer
));
780 /* Output the section data. */
781 start_time
= time (NULL
);
782 bfd_map_over_sections (abfd
, load_section
, &data_count
);
783 end_time
= time (NULL
);
785 /* Acknowledge the close packet and put the monitor back into
786 "normal" mode so it won't send packets any more. */
788 send_packet ('a', "", 0, 0);
789 monitor_expect_prompt (NULL
, 0);
790 monitor_printf ("vconsx\r");
791 monitor_expect_prompt (NULL
, 0);
793 /* Print download performance information. */
794 printf_filtered ("Start address 0x%lx\n", (long)bfd_get_start_address (abfd
));
795 report_transfer_performance (data_count
, start_time
, end_time
);
797 /* Finally, make the PC point at the start address */
799 write_pc (bfd_get_start_address (exec_bfd
));
801 inferior_pid
= 0; /* No process now */
803 /* This is necessary because many things were based on the PC at the
804 time that we attached to the monitor, which is no longer valid
805 now that we have loaded new code (and just changed the PC).
806 Another way to do this might be to call normal_stop, except that
807 the stack may not be valid, and things would get horribly
810 clear_symtab_users ();
814 static struct target_ops r3900_ops
;
816 /* Commands to send to the monitor when first connecting:
817 * The bare carriage return forces a prompt from the monitor
818 (monitor doesn't prompt after a reset).
819 * The "vconsx" switches the monitor back to interactive mode
820 in case an aborted download had left it in packet mode.
821 * The "Xtr" command causes subsequent "t" (trace) commands to display
822 the general registers only.
823 * The "Xxr" command does the same thing for the "x" (examine
825 * The "bx" command clears all breakpoints.
828 static char *r3900_inits
[] = {"\r", "vconsx\r", "Xtr\r", "Xxr\r", "bx\r", NULL
};
829 static char *dummy_inits
[] = { NULL
};
831 static struct monitor_ops r3900_cmds
;
834 r3900_open (args
, from_tty
)
841 monitor_open (args
, &r3900_cmds
, from_tty
);
843 /* We have to handle sending the init strings ourselves, because
844 the first two strings we send (carriage returns) may not be echoed
845 by the monitor, but the rest will be. */
846 monitor_printf_noecho ("\r\r");
847 for (i
= 0; r3900_inits
[i
] != NULL
; i
++)
849 monitor_printf (r3900_inits
[i
]);
850 monitor_expect_prompt (NULL
, 0);
853 /* Attempt to determine whether the console device is ethernet or serial.
854 This will tell us which kind of load to use (S-records over a serial
855 link, or the Densan fast binary multi-section format over the net). */
858 monitor_printf ("v\r");
859 if (monitor_expect ("console device :", NULL
, 0) != -1)
860 if (monitor_expect ("\n", buf
, sizeof (buf
)) != -1)
861 if (strstr (buf
, "ethernet") != NULL
)
863 monitor_expect_prompt (NULL
, 0);
867 _initialize_r3900_rom ()
869 r3900_cmds
.flags
= MO_NO_ECHO_ON_OPEN
|
870 MO_ADDR_BITS_REMOVE
|
871 MO_CLR_BREAK_USES_ADDR
|
872 MO_PRINT_PROGRAM_OUTPUT
;
874 r3900_cmds
.init
= dummy_inits
;
875 r3900_cmds
.cont
= "g\r";
876 r3900_cmds
.step
= "t\r";
877 r3900_cmds
.set_break
= "b %Lx\r"; /* COREADDR */
878 r3900_cmds
.clr_break
= "b %Lx,0\r"; /* COREADDR */
879 r3900_cmds
.fill
= "fx %Lx s %x %x\r"; /* COREADDR, len, val */
881 r3900_cmds
.setmem
.cmdb
= "sx %Lx %x\r"; /* COREADDR, val */
882 r3900_cmds
.setmem
.cmdw
= "sh %Lx %x\r"; /* COREADDR, val */
883 r3900_cmds
.setmem
.cmdl
= "sw %Lx %x\r"; /* COREADDR, val */
885 r3900_cmds
.getmem
.cmdb
= "dx %Lx s %x\r"; /* COREADDR, len */
886 r3900_cmds
.getmem
.resp_delim
= " : ";
888 r3900_cmds
.setreg
.cmd
= "x%s %x\r"; /* regname, val */
890 r3900_cmds
.getreg
.cmd
= "x%s\r"; /* regname */
891 r3900_cmds
.getreg
.resp_delim
= "=";
892 r3900_cmds
.getreg
.term
= " ";
893 r3900_cmds
.getreg
.term_cmd
= ".\r";
895 r3900_cmds
.dump_registers
= "x\r";
896 r3900_cmds
.register_pattern
=
897 "\\([a-zA-Z0-9_]+\\) *=\\([0-9a-f]+ [0-9a-f]+\\b\\)";
898 r3900_cmds
.supply_register
= r3900_supply_register
;
899 /* S-record download, via "keyboard port". */
900 r3900_cmds
.load
= "r0\r";
901 r3900_cmds
.prompt
= "#";
902 r3900_cmds
.line_term
= "\r";
903 r3900_cmds
.target
= &r3900_ops
;
904 r3900_cmds
.stopbits
= SERIAL_1_STOPBITS
;
905 r3900_cmds
.regnames
= r3900_regnames
;
906 r3900_cmds
.magic
= MONITOR_OPS_MAGIC
;
908 init_monitor_ops (&r3900_ops
);
910 r3900_ops
.to_shortname
= "r3900";
911 r3900_ops
.to_longname
= "R3900 monitor";
912 r3900_ops
.to_doc
= "Debug using the DVE R3900 monitor.\n\
913 Specify the serial device it is connected to (e.g. /dev/ttya).";
914 r3900_ops
.to_open
= r3900_open
;
916 /* Override the functions to fetch and store registers. But save the
917 addresses of the default functions, because we will use those functions
918 for "normal" registers. */
920 orig_monitor_fetch_registers
= r3900_ops
.to_fetch_registers
;
921 orig_monitor_store_registers
= r3900_ops
.to_store_registers
;
922 r3900_ops
.to_fetch_registers
= r3900_fetch_registers
;
923 r3900_ops
.to_store_registers
= r3900_store_registers
;
925 /* Override the load function, but save the address of the default
926 function to use when loading S-records over a serial link. */
927 orig_monitor_load
= r3900_ops
.to_load
;
928 r3900_ops
.to_load
= r3900_load
;
930 add_target (&r3900_ops
);