1 /* Memory-access and commands for remote NINDY process, for GDB.
2 Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc.
3 Contributed by Intel Corporation. Modified from remote.c by Chris Benenati.
5 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
6 WARRANTY. No author or distributor accepts responsibility to anyone
7 for the consequences of using it or for whether it serves any
8 particular purpose or works at all, unless he says so in writing.
9 Refer to the GDB General Public License for full details.
11 Everyone is granted permission to copy, modify and redistribute GDB,
12 but only under the conditions described in the GDB General Public
13 License. A copy of this license is supposed to have been given to you
14 along with GDB so you can know your rights and responsibilities. It
15 should be in a file named COPYING. Among other things, the copyright
16 notice and this notice must be preserved on all copies.
18 In other words, go ahead and share GDB, but don't try to stop
19 anyone else from sharing it farther. Help stamp out software hoarding!
23 Except for the data cache routines, this file bears little resemblence
24 to remote.c. A new (although similar) protocol has been specified, and
25 portions of the code are entirely dependent on having an i80960 with a
26 NINDY ROM monitor at the other end of the line.
29 /*****************************************************************************
31 * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR.
37 * As far as NINDY is concerned, GDB is always in one of two modes: command
38 * mode or passthrough mode.
40 * In command mode (the default) pre-defined packets containing requests
41 * are sent by GDB to NINDY. NINDY never talks except in reponse to a request.
43 * Once the the user program is started, GDB enters passthrough mode, to give
44 * the user program access to the terminal. GDB remains in this mode until
45 * NINDY indicates that the program has stopped.
51 * GDB writes all input received from the keyboard directly to NINDY, and writes
52 * all characters received from NINDY directly to the monitor.
54 * Keyboard input is neither buffered nor echoed to the monitor.
56 * GDB remains in passthrough mode until NINDY sends a single ^P character,
57 * to indicate that the user process has stopped.
60 * GDB assumes NINDY performs a 'flushreg' when the user program stops.
66 * All info (except for message ack and nak) is transferred between gdb
67 * and the remote processor in messages of the following format:
72 * # is a literal character
74 * <info> ASCII information; all numeric information is in the
75 * form of hex digits ('0'-'9' and lowercase 'a'-'f').
78 * is a pair of ASCII hex digits representing an 8-bit
79 * checksum formed by adding together each of the
80 * characters in <info>.
82 * The receiver of a message always sends a single character to the sender
83 * to indicate that the checksum was good ('+') or bad ('-'); the sender
84 * re-transmits the entire message over until a '+' is received.
86 * In response to a command NINDY always sends back either data or
87 * a result code of the form "Xnn", where "nn" are hex digits and "X00"
88 * means no errors. (Exceptions: the "s" and "c" commands don't respond.)
90 * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A
91 * FULL DESCRIPTION OF LEGAL COMMANDS.
93 * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST
96 ******************************************************************************/
100 #include <sys/types.h>
104 #include "inferior.h"
110 #include "ieee-float.h"
113 #include <sys/ioctl.h>
114 #include <sys/file.h>
118 #include "nindy-share/ttycntl.h"
119 #include "nindy-share/demux.h"
121 #include "nindy-share/env.h"
122 #include "nindy-share/stop.h"
125 extern char *getenv();
126 extern char *mktemp();
128 extern void generic_mourn_inferior ();
130 extern struct target_ops nindy_ops
;
131 extern FILE *instream
;
132 extern struct ext_format ext_format_i960
; /* i960-tdep.c */
134 extern char ninStopWhy ();
136 int nindy_initial_brk
; /* nonzero if want to send an initial BREAK to nindy */
137 int nindy_old_protocol
; /* nonzero if want to use old protocol */
138 char *nindy_ttyname
; /* name of tty to talk to nindy on, or null */
140 #define DLE '\020' /* Character NINDY sends to indicate user program has
145 /* From nindy-share/nindy.c. */
146 extern serial_t nindy_serial
;
148 static int have_regs
= 0; /* 1 iff regs read since i960 last halted */
149 static int regs_changed
= 0; /* 1 iff regs were modified since last read */
151 extern char *exists();
154 dcache_flush (), dcache_poke (), dcache_init();
160 nindy_fetch_registers
PARAMS ((int));
163 nindy_store_registers
PARAMS ((int));
165 static char *savename
;
168 nindy_close (quitting
)
171 if (nindy_serial
!= NULL
)
172 SERIAL_CLOSE (nindy_serial
);
180 /* Open a connection to a remote debugger.
181 FIXME, there should be a way to specify the various options that are
182 now specified with gdb command-line options. (baud_rate, old_protocol,
185 nindy_open (name
, from_tty
)
186 char *name
; /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
191 error_no_arg ("serial port device name");
193 target_preopen (from_tty
);
197 have_regs
= regs_changed
= 0;
200 /* Allow user to interrupt the following -- we could hang if there's
201 no NINDY at the other end of the remote tty. */
203 ninConnect(name
, baud_rate
? baud_rate
: "9600",
204 nindy_initial_brk
, !from_tty
, nindy_old_protocol
);
207 if (nindy_serial
== NULL
)
209 perror_with_name (name
);
212 savename
= savestring (name
, strlen (name
));
213 push_target (&nindy_ops
);
214 target_fetch_registers(-1);
217 /* User-initiated quit of nindy operations. */
220 nindy_detach (name
, from_tty
)
225 error ("Too many arguments");
232 printf("\tAttached to %s at %s bps%s%s.\n", savename
,
233 baud_rate
? baud_rate
: "9600",
234 nindy_old_protocol
? " in old protocol": "",
235 nindy_initial_brk
? " with initial break": "");
238 /* Return the number of characters in the buffer before
239 the first DLE character. */
244 char *buf
; /* Character buffer; NOT '\0'-terminated */
245 int n
; /* Number of characters in buffer */
249 for ( i
= 0; i
< n
; i
++ ){
250 if ( buf
[i
] == DLE
){
257 /* Tell the remote machine to resume. */
260 nindy_resume (step
, siggnal
)
263 if (siggnal
!= 0 && siggnal
!= stop_signal
)
264 error ("Can't send signals to remote NINDY targets.");
268 nindy_store_registers (-1);
275 /* FIXME, we can probably use the normal terminal_inferior stuff here.
276 We have to do terminal_inferior and then set up the passthrough
277 settings initially. Thereafter, terminal_ours and terminal_inferior
278 will automatically swap the settings around for us. */
280 struct clean_up_tty_args
{
281 serial_ttystate state
;
286 clean_up_tty (ptrarg
)
289 struct clean_up_tty_args
*args
= (struct clean_up_tty_args
*) ptrarg
;
290 SERIAL_SET_TTY_STATE (args
->serial
, args
->state
);
293 You may need to reset the 80960 and/or reload your program.\n");
296 /* Wait until the remote machine stops. While waiting, operate in passthrough
297 * mode; i.e., pass everything NINDY sends to stdout, and everything from
300 * Return to caller, storing status in 'status' just as `wait' would.
308 char buf
[500]; /* FIXME, what is "500" here? */
310 unsigned char stop_exit
;
311 unsigned char stop_code
;
312 struct clean_up_tty_args tty_args
;
313 struct cleanup
*old_cleanups
;
314 long ip_value
, fp_value
, sp_value
; /* Reg values from stop */
316 WSETEXIT( (*status
), 0 );
318 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
320 /* Save current tty attributes, and restore them when done. */
321 tty_args
.serial
= SERIAL_FDOPEN (0);
322 tty_args
.state
= SERIAL_GET_TTY_STATE (tty_args
.serial
);
323 old_cleanups
= make_cleanup (clean_up_tty
, &tty_args
);
325 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
326 <CR> and perform echo. */
327 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
329 SERIAL_RAW (tty_args
.serial
);
333 /* Wait for input on either the remote port or stdin. */
336 FD_SET (nindy_serial
->fd
, &fds
);
337 if (select (nindy_serial
->fd
+ 1, &fds
, 0, 0, 0) <= 0)
340 /* Pass input through to correct place */
341 if (FD_ISSET (0, &fds
))
344 n
= read (0, buf
, sizeof (buf
));
347 SERIAL_WRITE (nindy_serial
, buf
, n
);
351 if (FD_ISSET (nindy_serial
->fd
, &fds
))
353 /* Input on remote */
354 n
= read (nindy_serial
->fd
, buf
, sizeof (buf
));
357 /* Write out any characters in buffer preceding DLE */
358 i
= non_dle( buf
, n
);
366 /* There *was* a DLE in the buffer */
367 stop_exit
= ninStopWhy(&stop_code
,
368 &ip_value
, &fp_value
, &sp_value
);
369 if (!stop_exit
&& (stop_code
== STOP_SRQ
))
377 /* Get out of loop */
378 supply_register (IP_REGNUM
,
380 supply_register (FP_REGNUM
,
382 supply_register (SP_REGNUM
,
391 do_cleanups (old_cleanups
);
395 /* User program exited */
396 WSETEXIT ((*status
), stop_code
);
405 /* Breakpoint or single stepping. */
409 /* The target is not running Unix, and its faults/traces do
410 not map nicely into Unix signals. Make sure they do not
411 get confused with Unix signals by numbering them with
412 values higher than the highest legal Unix signal. code
413 in i960_print_fault(), called via PRINT_RANDOM_SIGNAL,
414 will interpret the value. */
418 WSETSTOP ((*status
), stop_code
);
423 /* Read the remote registers into the block REGS. */
425 /* This is the block that ninRegsGet and ninRegsPut handles. */
427 char local_regs
[16 * 4];
428 char global_regs
[16 * 4];
432 char fp_as_double
[4 * 8];
436 nindy_fetch_registers(regno
)
439 struct nindy_regs nindy_regs
;
444 ninRegsGet( (char *) &nindy_regs
);
447 memcpy (®isters
[REGISTER_BYTE (R0_REGNUM
)], nindy_regs
.local_regs
, 16*4);
448 memcpy (®isters
[REGISTER_BYTE (G0_REGNUM
)], nindy_regs
.global_regs
, 16*4);
449 memcpy (®isters
[REGISTER_BYTE (PCW_REGNUM
)], nindy_regs
.pcw_acw
, 2*4);
450 memcpy (®isters
[REGISTER_BYTE (IP_REGNUM
)], nindy_regs
.ip
, 1*4);
451 memcpy (®isters
[REGISTER_BYTE (TCW_REGNUM
)], nindy_regs
.tcw
, 1*4);
452 for (regnum
= FP0_REGNUM
; regnum
< FP0_REGNUM
+ 4; regnum
++) {
453 dub
= unpack_double (builtin_type_double
,
454 &nindy_regs
.fp_as_double
[8 * (regnum
- FP0_REGNUM
)],
456 /* dub now in host byte order */
457 double_to_ieee_extended (&ext_format_i960
, &dub
,
458 ®isters
[REGISTER_BYTE (regnum
)]);
461 registers_fetched ();
465 nindy_prepare_to_store()
467 /* Fetch all regs if they aren't already here. */
468 read_register_bytes (0, NULL
, REGISTER_BYTES
);
472 nindy_store_registers(regno
)
475 struct nindy_regs nindy_regs
;
479 memcpy (nindy_regs
.local_regs
, ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16*4);
480 memcpy (nindy_regs
.global_regs
, ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16*4);
481 memcpy (nindy_regs
.pcw_acw
, ®isters
[REGISTER_BYTE (PCW_REGNUM
)], 2*4);
482 memcpy (nindy_regs
.ip
, ®isters
[REGISTER_BYTE (IP_REGNUM
)], 1*4);
483 memcpy (nindy_regs
.tcw
, ®isters
[REGISTER_BYTE (TCW_REGNUM
)], 1*4);
484 /* Float regs. Only works on IEEE_FLOAT hosts. FIXME! */
485 for (regnum
= FP0_REGNUM
; regnum
< FP0_REGNUM
+ 4; regnum
++) {
486 ieee_extended_to_double (&ext_format_i960
,
487 ®isters
[REGISTER_BYTE (regnum
)], &dub
);
488 /* dub now in host byte order */
489 /* FIXME-someday, the arguments to unpack_double are backward.
490 It expects a target double and returns a host; we pass the opposite.
491 This mostly works but not quite. */
492 dub
= unpack_double (builtin_type_double
, (char *)&dub
, &inv
);
493 /* dub now in target byte order */
494 memcpy (&nindy_regs
.fp_as_double
[8 * (regnum
- FP0_REGNUM
)], &dub
, 8);
498 ninRegsPut( (char *) &nindy_regs
);
502 /* Read a word from remote address ADDR and return it.
503 * This goes through the data cache.
506 nindy_fetch_word (addr
)
509 return dcache_fetch (addr
);
512 /* Write a word WORD into remote address ADDR.
513 This goes through the data cache. */
516 nindy_store_word (addr
, word
)
520 dcache_poke (addr
, word
);
523 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
524 to debugger memory starting at MYADDR. Copy to inferior if
525 WRITE is nonzero. Returns the length copied.
527 This is stolen almost directly from infptrace.c's child_xfer_memory,
528 which also deals with a word-oriented memory interface. Sometime,
529 FIXME, rewrite this to not use the word-oriented routines. */
532 nindy_xfer_inferior_memory(memaddr
, myaddr
, len
, write
, target
)
537 struct target_ops
*target
; /* ignored */
540 /* Round starting address down to longword boundary. */
541 register CORE_ADDR addr
= memaddr
& - sizeof (int);
542 /* Round ending address up; get number of longwords that makes. */
544 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
545 /* Allocate buffer of that many longwords. */
546 register int *buffer
= (int *) alloca (count
* sizeof (int));
550 /* Fill start and end extra bytes of buffer with existing memory data. */
552 if (addr
!= memaddr
|| len
< (int)sizeof (int)) {
553 /* Need part of initial word -- fetch it. */
554 buffer
[0] = nindy_fetch_word (addr
);
557 if (count
> 1) /* FIXME, avoid if even boundary */
560 = nindy_fetch_word (addr
+ (count
- 1) * sizeof (int));
563 /* Copy data to be written over corresponding part of buffer */
565 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
567 /* Write the entire buffer. */
569 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
572 nindy_store_word (addr
, buffer
[i
]);
579 /* Read all the longwords */
580 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
583 buffer
[i
] = nindy_fetch_word (addr
);
589 /* Copy appropriate bytes out of the buffer. */
590 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
595 /* The data cache records all the data read from the remote machine
596 since the last time it stopped.
598 Each cache block holds 16 bytes of data
599 starting at a multiple-of-16 address. */
601 #define DCACHE_SIZE 64 /* Number of cache blocks */
603 struct dcache_block
{
604 struct dcache_block
*next
, *last
;
605 unsigned int addr
; /* Address for which data is recorded. */
609 struct dcache_block dcache_free
, dcache_valid
;
611 /* Free all the data cache blocks, thus discarding all cached data. */
616 register struct dcache_block
*db
;
618 while ((db
= dcache_valid
.next
) != &dcache_valid
)
621 insque (db
, &dcache_free
);
626 * If addr is present in the dcache, return the address of the block
630 struct dcache_block
*
634 register struct dcache_block
*db
;
639 /* Search all cache blocks for one that is at this address. */
640 db
= dcache_valid
.next
;
641 while (db
!= &dcache_valid
)
643 if ((addr
& 0xfffffff0) == db
->addr
)
650 /* Return the int data at address ADDR in dcache block DC. */
653 dcache_value (db
, addr
)
654 struct dcache_block
*db
;
659 return (db
->data
[(addr
>>2)&3]);
662 /* Get a free cache block, put or keep it on the valid list,
663 and return its address. The caller should store into the block
664 the address and data that it describes, then remque it from the
665 free list and insert it into the valid list. This procedure
666 prevents errors from creeping in if a ninMemGet is interrupted
667 (which used to put garbage blocks in the valid list...). */
669 struct dcache_block
*
672 register struct dcache_block
*db
;
674 if ((db
= dcache_free
.next
) == &dcache_free
)
676 /* If we can't get one from the free list, take last valid and put
677 it on the free list. */
678 db
= dcache_valid
.last
;
680 insque (db
, &dcache_free
);
684 insque (db
, &dcache_valid
);
688 /* Return the contents of the word at address ADDR in the remote machine,
689 using the data cache. */
695 register struct dcache_block
*db
;
697 db
= dcache_hit (addr
);
700 db
= dcache_alloc ();
702 ninMemGet(addr
& ~0xf, (unsigned char *)db
->data
, 16);
704 db
->addr
= addr
& ~0xf;
705 remque (db
); /* Off the free list */
706 insque (db
, &dcache_valid
); /* On the valid list */
708 return (dcache_value (db
, addr
));
711 /* Write the word at ADDR both in the data cache and in the remote machine. */
713 dcache_poke (addr
, data
)
717 register struct dcache_block
*db
;
719 /* First make sure the word is IN the cache. DB is its cache block. */
720 db
= dcache_hit (addr
);
723 db
= dcache_alloc ();
725 ninMemGet(addr
& ~0xf, (unsigned char *)db
->data
, 16);
727 db
->addr
= addr
& ~0xf;
728 remque (db
); /* Off the free list */
729 insque (db
, &dcache_valid
); /* On the valid list */
732 /* Modify the word in the cache. */
733 db
->data
[(addr
>>2)&3] = data
;
735 /* Send the changed word. */
737 ninMemPut(addr
, (unsigned char *)&data
, 4);
741 /* The cache itself. */
742 struct dcache_block the_cache
[DCACHE_SIZE
];
744 /* Initialize the data cache. */
749 register struct dcache_block
*db
;
752 dcache_free
.next
= dcache_free
.last
= &dcache_free
;
753 dcache_valid
.next
= dcache_valid
.last
= &dcache_valid
;
754 for (i
=0;i
<DCACHE_SIZE
;i
++,db
++)
755 insque (db
, &dcache_free
);
760 nindy_create_inferior (execfile
, args
, env
)
769 error ("Can't pass arguments to remote NINDY process");
771 if (execfile
== 0 || exec_bfd
== 0)
772 error ("No exec file specified");
774 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
778 #ifdef CREATE_INFERIOR_HOOK
779 CREATE_INFERIOR_HOOK (pid
);
782 /* The "process" (board) is already stopped awaiting our commands, and
783 the program is already downloaded. We just set its PC and go. */
785 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
787 clear_proceed_status ();
789 /* Tell wait_for_inferior that we've started a new process. */
790 init_wait_for_inferior ();
792 /* Set up the "saved terminal modes" of the inferior
793 based on what modes we are starting it with. */
794 target_terminal_init ();
796 /* Install inferior's terminal modes. */
797 target_terminal_inferior ();
799 /* insert_step_breakpoint (); FIXME, do we need this? */
800 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
804 reset_command(args
, from_tty
)
808 if (nindy_serial
== NULL
)
810 error( "No target system to reset -- use 'target nindy' command.");
812 if ( query("Really reset the target system?",0,0) )
814 SERIAL_SEND_BREAK (nindy_serial
);
815 tty_flush (nindy_serial
);
820 nindy_kill (args
, from_tty
)
824 return; /* Ignore attempts to kill target system */
827 /* Clean up when a program exits.
829 The program actually lives on in the remote processor's RAM, and may be
830 run again without a download. Don't leave it full of breakpoint
834 nindy_mourn_inferior ()
836 remove_breakpoints ();
837 unpush_target (&nindy_ops
);
838 generic_mourn_inferior (); /* Do all the proper things now */
841 /* Pass the args the way catch_errors wants them. */
843 nindy_open_stub (arg
)
854 target_load (arg
, 1);
858 /* This routine is run as a hook, just before the main command loop is
859 entered. If gdb is configured for the i960, but has not had its
860 nindy target specified yet, this will loop prompting the user to do so.
862 Unlike the loop provided by Intel, we actually let the user get out
863 of this with a RETURN. This is useful when e.g. simply examining
864 an i960 object file on the host system. */
867 nindy_before_main_loop ()
872 while (current_target
!= &nindy_ops
) { /* remote tty not specified yet */
873 if ( instream
== stdin
){
874 printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
877 fgets( ttyname
, sizeof(ttyname
)-1, stdin
);
879 /* Strip leading and trailing whitespace */
880 for ( p
= ttyname
; isspace(*p
); p
++ ){
884 return; /* User just hit spaces or return, wants out */
886 for ( p2
= p
; !isspace(*p2
) && (*p2
!= '\0'); p2
++ ){
890 if ( STREQ("quit",p
) ){
894 if (catch_errors (nindy_open_stub
, p
, "", RETURN_MASK_ALL
))
896 /* Now that we have a tty open for talking to the remote machine,
897 download the executable file if one was specified. */
900 catch_errors (load_stub
, bfd_get_filename (exec_bfd
), "",
907 /* Define the target subroutine names */
909 struct target_ops nindy_ops
= {
910 "nindy", "Remote serial target in i960 NINDY-specific protocol",
911 "Use a remote i960 system running NINDY connected by a serial line.\n\
912 Specify the name of the device the serial line is connected to.\n\
913 The speed (baud rate), whether to use the old NINDY protocol,\n\
914 and whether to send a break on startup, are controlled by options\n\
915 specified when you started GDB.",
916 nindy_open
, nindy_close
,
921 nindy_fetch_registers
, nindy_store_registers
,
922 nindy_prepare_to_store
,
923 nindy_xfer_inferior_memory
, nindy_files_info
,
924 0, 0, /* insert_breakpoint, remove_breakpoint, */
925 0, 0, 0, 0, 0, /* Terminal crud */
928 0, /* lookup_symbol */
929 nindy_create_inferior
,
930 nindy_mourn_inferior
,
932 0, /* notice_signals */
933 process_stratum
, 0, /* next */
934 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
935 0, 0, /* Section pointers */
936 OPS_MAGIC
, /* Always the last thing */
942 add_target (&nindy_ops
);
943 add_com ("reset", class_obscure
, reset_command
,
944 "Send a 'break' to the remote target system.\n\
945 Only useful if the target has been equipped with a circuit\n\
946 to perform a hard reset when a break is detected.");