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/file.h>
116 #include "nindy-share/env.h"
117 #include "nindy-share/stop.h"
120 #include "remote-utils.h"
122 static DCACHE
*nindy_dcache
;
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 ();
135 extern int ninMemGet ();
136 extern int ninMemPut ();
138 int nindy_initial_brk
; /* nonzero if want to send an initial BREAK to nindy */
139 int nindy_old_protocol
; /* nonzero if want to use old protocol */
140 char *nindy_ttyname
; /* name of tty to talk to nindy on, or null */
142 #define DLE '\020' /* Character NINDY sends to indicate user program has
147 /* From nindy-share/nindy.c. */
148 extern serial_t nindy_serial
;
150 static int have_regs
= 0; /* 1 iff regs read since i960 last halted */
151 static int regs_changed
= 0; /* 1 iff regs were modified since last read */
153 extern char *exists();
156 nindy_fetch_registers
PARAMS ((int));
159 nindy_store_registers
PARAMS ((int));
161 static char *savename
;
164 nindy_close (quitting
)
167 if (nindy_serial
!= NULL
)
168 SERIAL_CLOSE (nindy_serial
);
176 /* Open a connection to a remote debugger.
177 FIXME, there should be a way to specify the various options that are
178 now specified with gdb command-line options. (baud_rate, old_protocol,
181 nindy_open (name
, from_tty
)
182 char *name
; /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
188 error_no_arg ("serial port device name");
190 target_preopen (from_tty
);
194 have_regs
= regs_changed
= 0;
195 nindy_dcache
= dcache_init(ninMemGet
, ninMemPut
);
197 /* Allow user to interrupt the following -- we could hang if there's
198 no NINDY at the other end of the remote tty. */
200 sprintf(baudrate
, "%d", sr_get_baud_rate());
201 ninConnect(name
, baudrate
,
202 nindy_initial_brk
, !from_tty
, nindy_old_protocol
);
205 if (nindy_serial
== NULL
)
207 perror_with_name (name
);
210 savename
= savestring (name
, strlen (name
));
211 push_target (&nindy_ops
);
212 target_fetch_registers(-1);
215 /* User-initiated quit of nindy operations. */
218 nindy_detach (name
, from_tty
)
223 error ("Too many arguments");
230 printf("\tAttached to %s at %d bps%s%s.\n", savename
,
232 nindy_old_protocol
? " in old protocol": "",
233 nindy_initial_brk
? " with initial break": "");
236 /* Return the number of characters in the buffer before
237 the first DLE character. */
242 char *buf
; /* Character buffer; NOT '\0'-terminated */
243 int n
; /* Number of characters in buffer */
247 for ( i
= 0; i
< n
; i
++ ){
248 if ( buf
[i
] == DLE
){
255 /* Tell the remote machine to resume. */
258 nindy_resume (pid
, step
, siggnal
)
259 int pid
, step
, siggnal
;
261 if (siggnal
!= 0 && siggnal
!= stop_signal
)
262 error ("Can't send signals to remote NINDY targets.");
264 dcache_flush(nindy_dcache
);
266 nindy_store_registers (-1);
273 /* FIXME, we can probably use the normal terminal_inferior stuff here.
274 We have to do terminal_inferior and then set up the passthrough
275 settings initially. Thereafter, terminal_ours and terminal_inferior
276 will automatically swap the settings around for us. */
278 struct clean_up_tty_args
{
279 serial_ttystate state
;
284 clean_up_tty (ptrarg
)
287 struct clean_up_tty_args
*args
= (struct clean_up_tty_args
*) ptrarg
;
288 SERIAL_SET_TTY_STATE (args
->serial
, args
->state
);
291 You may need to reset the 80960 and/or reload your program.\n");
294 /* Wait until the remote machine stops. While waiting, operate in passthrough
295 * mode; i.e., pass everything NINDY sends to stdout, and everything from
298 * Return to caller, storing status in 'status' just as `wait' would.
306 char buf
[500]; /* FIXME, what is "500" here? */
308 unsigned char stop_exit
;
309 unsigned char stop_code
;
310 struct clean_up_tty_args tty_args
;
311 struct cleanup
*old_cleanups
;
312 long ip_value
, fp_value
, sp_value
; /* Reg values from stop */
314 WSETEXIT( (*status
), 0 );
316 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
318 /* Save current tty attributes, and restore them when done. */
319 tty_args
.serial
= SERIAL_FDOPEN (0);
320 tty_args
.state
= SERIAL_GET_TTY_STATE (tty_args
.serial
);
321 old_cleanups
= make_cleanup (clean_up_tty
, &tty_args
);
323 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
324 <CR> and perform echo. */
325 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
327 SERIAL_RAW (tty_args
.serial
);
331 /* Wait for input on either the remote port or stdin. */
334 FD_SET (nindy_serial
->fd
, &fds
);
335 if (select (nindy_serial
->fd
+ 1, &fds
, 0, 0, 0) <= 0)
338 /* Pass input through to correct place */
339 if (FD_ISSET (0, &fds
))
342 n
= read (0, buf
, sizeof (buf
));
345 SERIAL_WRITE (nindy_serial
, buf
, n
);
349 if (FD_ISSET (nindy_serial
->fd
, &fds
))
351 /* Input on remote */
352 n
= read (nindy_serial
->fd
, buf
, sizeof (buf
));
355 /* Write out any characters in buffer preceding DLE */
356 i
= non_dle( buf
, n
);
364 /* There *was* a DLE in the buffer */
365 stop_exit
= ninStopWhy(&stop_code
,
366 &ip_value
, &fp_value
, &sp_value
);
367 if (!stop_exit
&& (stop_code
== STOP_SRQ
))
375 /* Get out of loop */
376 supply_register (IP_REGNUM
,
378 supply_register (FP_REGNUM
,
380 supply_register (SP_REGNUM
,
389 do_cleanups (old_cleanups
);
393 /* User program exited */
394 WSETEXIT ((*status
), stop_code
);
403 /* Breakpoint or single stepping. */
407 /* The target is not running Unix, and its faults/traces do
408 not map nicely into Unix signals. Make sure they do not
409 get confused with Unix signals by numbering them with
410 values higher than the highest legal Unix signal. code
411 in i960_print_fault(), called via PRINT_RANDOM_SIGNAL,
412 will interpret the value. */
416 WSETSTOP ((*status
), stop_code
);
421 /* Read the remote registers into the block REGS. */
423 /* This is the block that ninRegsGet and ninRegsPut handles. */
425 char local_regs
[16 * 4];
426 char global_regs
[16 * 4];
430 char fp_as_double
[4 * 8];
434 nindy_fetch_registers(regno
)
437 struct nindy_regs nindy_regs
;
442 ninRegsGet( (char *) &nindy_regs
);
445 memcpy (®isters
[REGISTER_BYTE (R0_REGNUM
)], nindy_regs
.local_regs
, 16*4);
446 memcpy (®isters
[REGISTER_BYTE (G0_REGNUM
)], nindy_regs
.global_regs
, 16*4);
447 memcpy (®isters
[REGISTER_BYTE (PCW_REGNUM
)], nindy_regs
.pcw_acw
, 2*4);
448 memcpy (®isters
[REGISTER_BYTE (IP_REGNUM
)], nindy_regs
.ip
, 1*4);
449 memcpy (®isters
[REGISTER_BYTE (TCW_REGNUM
)], nindy_regs
.tcw
, 1*4);
450 for (regnum
= FP0_REGNUM
; regnum
< FP0_REGNUM
+ 4; regnum
++) {
451 dub
= unpack_double (builtin_type_double
,
452 &nindy_regs
.fp_as_double
[8 * (regnum
- FP0_REGNUM
)],
454 /* dub now in host byte order */
455 double_to_ieee_extended (&ext_format_i960
, &dub
,
456 ®isters
[REGISTER_BYTE (regnum
)]);
459 registers_fetched ();
463 nindy_prepare_to_store()
465 /* Fetch all regs if they aren't already here. */
466 read_register_bytes (0, NULL
, REGISTER_BYTES
);
470 nindy_store_registers(regno
)
473 struct nindy_regs nindy_regs
;
477 memcpy (nindy_regs
.local_regs
, ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16*4);
478 memcpy (nindy_regs
.global_regs
, ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16*4);
479 memcpy (nindy_regs
.pcw_acw
, ®isters
[REGISTER_BYTE (PCW_REGNUM
)], 2*4);
480 memcpy (nindy_regs
.ip
, ®isters
[REGISTER_BYTE (IP_REGNUM
)], 1*4);
481 memcpy (nindy_regs
.tcw
, ®isters
[REGISTER_BYTE (TCW_REGNUM
)], 1*4);
482 /* Float regs. Only works on IEEE_FLOAT hosts. FIXME! */
483 for (regnum
= FP0_REGNUM
; regnum
< FP0_REGNUM
+ 4; regnum
++) {
484 ieee_extended_to_double (&ext_format_i960
,
485 ®isters
[REGISTER_BYTE (regnum
)], &dub
);
486 /* dub now in host byte order */
487 /* FIXME-someday, the arguments to unpack_double are backward.
488 It expects a target double and returns a host; we pass the opposite.
489 This mostly works but not quite. */
490 dub
= unpack_double (builtin_type_double
, (char *)&dub
, &inv
);
491 /* dub now in target byte order */
492 memcpy (&nindy_regs
.fp_as_double
[8 * (regnum
- FP0_REGNUM
)], &dub
, 8);
496 ninRegsPut( (char *) &nindy_regs
);
500 /* Read a word from remote address ADDR and return it.
501 * This goes through the data cache.
504 nindy_fetch_word (addr
)
507 return dcache_fetch (nindy_dcache
, addr
);
510 /* Write a word WORD into remote address ADDR.
511 This goes through the data cache. */
514 nindy_store_word (addr
, word
)
518 dcache_poke (nindy_dcache
, addr
, word
);
521 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
522 to debugger memory starting at MYADDR. Copy to inferior if
523 WRITE is nonzero. Returns the length copied.
525 This is stolen almost directly from infptrace.c's child_xfer_memory,
526 which also deals with a word-oriented memory interface. Sometime,
527 FIXME, rewrite this to not use the word-oriented routines. */
530 nindy_xfer_inferior_memory(memaddr
, myaddr
, len
, write
, target
)
535 struct target_ops
*target
; /* ignored */
538 /* Round starting address down to longword boundary. */
539 register CORE_ADDR addr
= memaddr
& - sizeof (int);
540 /* Round ending address up; get number of longwords that makes. */
542 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
543 /* Allocate buffer of that many longwords. */
544 register int *buffer
= (int *) alloca (count
* sizeof (int));
548 /* Fill start and end extra bytes of buffer with existing memory data. */
550 if (addr
!= memaddr
|| len
< (int)sizeof (int)) {
551 /* Need part of initial word -- fetch it. */
552 buffer
[0] = nindy_fetch_word (addr
);
555 if (count
> 1) /* FIXME, avoid if even boundary */
558 = nindy_fetch_word (addr
+ (count
- 1) * sizeof (int));
561 /* Copy data to be written over corresponding part of buffer */
563 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
565 /* Write the entire buffer. */
567 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
570 nindy_store_word (addr
, buffer
[i
]);
577 /* Read all the longwords */
578 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
581 buffer
[i
] = nindy_fetch_word (addr
);
587 /* Copy appropriate bytes out of the buffer. */
588 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
594 nindy_create_inferior (execfile
, args
, env
)
603 error ("Can't pass arguments to remote NINDY process");
605 if (execfile
== 0 || exec_bfd
== 0)
606 error ("No exec file specified");
608 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
612 #ifdef CREATE_INFERIOR_HOOK
613 CREATE_INFERIOR_HOOK (pid
);
616 /* The "process" (board) is already stopped awaiting our commands, and
617 the program is already downloaded. We just set its PC and go. */
619 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
621 clear_proceed_status ();
623 /* Tell wait_for_inferior that we've started a new process. */
624 init_wait_for_inferior ();
626 /* Set up the "saved terminal modes" of the inferior
627 based on what modes we are starting it with. */
628 target_terminal_init ();
630 /* Install inferior's terminal modes. */
631 target_terminal_inferior ();
633 /* insert_step_breakpoint (); FIXME, do we need this? */
634 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
638 reset_command(args
, from_tty
)
642 if (nindy_serial
== NULL
)
644 error( "No target system to reset -- use 'target nindy' command.");
646 if ( query("Really reset the target system?",0,0) )
648 SERIAL_SEND_BREAK (nindy_serial
);
649 tty_flush (nindy_serial
);
654 nindy_kill (args
, from_tty
)
658 return; /* Ignore attempts to kill target system */
661 /* Clean up when a program exits.
663 The program actually lives on in the remote processor's RAM, and may be
664 run again without a download. Don't leave it full of breakpoint
668 nindy_mourn_inferior ()
670 remove_breakpoints ();
671 unpush_target (&nindy_ops
);
672 generic_mourn_inferior (); /* Do all the proper things now */
675 /* Pass the args the way catch_errors wants them. */
677 nindy_open_stub (arg
)
688 target_load (arg
, 1);
692 /* This routine is run as a hook, just before the main command loop is
693 entered. If gdb is configured for the i960, but has not had its
694 nindy target specified yet, this will loop prompting the user to do so.
696 Unlike the loop provided by Intel, we actually let the user get out
697 of this with a RETURN. This is useful when e.g. simply examining
698 an i960 object file on the host system. */
701 nindy_before_main_loop ()
706 while (current_target
!= &nindy_ops
) { /* remote tty not specified yet */
707 if ( instream
== stdin
){
708 printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
711 fgets( ttyname
, sizeof(ttyname
)-1, stdin
);
713 /* Strip leading and trailing whitespace */
714 for ( p
= ttyname
; isspace(*p
); p
++ ){
718 return; /* User just hit spaces or return, wants out */
720 for ( p2
= p
; !isspace(*p2
) && (*p2
!= '\0'); p2
++ ){
724 if ( STREQ("quit",p
) ){
728 if (catch_errors (nindy_open_stub
, p
, "", RETURN_MASK_ALL
))
730 /* Now that we have a tty open for talking to the remote machine,
731 download the executable file if one was specified. */
734 catch_errors (load_stub
, bfd_get_filename (exec_bfd
), "",
741 /* Define the target subroutine names */
743 struct target_ops nindy_ops
= {
744 "nindy", "Remote serial target in i960 NINDY-specific protocol",
745 "Use a remote i960 system running NINDY connected by a serial line.\n\
746 Specify the name of the device the serial line is connected to.\n\
747 The speed (baud rate), whether to use the old NINDY protocol,\n\
748 and whether to send a break on startup, are controlled by options\n\
749 specified when you started GDB.",
750 nindy_open
, nindy_close
,
755 nindy_fetch_registers
, nindy_store_registers
,
756 nindy_prepare_to_store
,
757 nindy_xfer_inferior_memory
, nindy_files_info
,
758 0, 0, /* insert_breakpoint, remove_breakpoint, */
759 0, 0, 0, 0, 0, /* Terminal crud */
762 0, /* lookup_symbol */
763 nindy_create_inferior
,
764 nindy_mourn_inferior
,
766 0, /* notice_signals */
767 process_stratum
, 0, /* next */
768 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
769 0, 0, /* Section pointers */
770 OPS_MAGIC
, /* Always the last thing */
776 add_target (&nindy_ops
);
777 add_com ("reset", class_obscure
, reset_command
,
778 "Send a 'break' to the remote target system.\n\
779 Only useful if the target has been equipped with a circuit\n\
780 to perform a hard reset when a break is detected.");