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 "floatformat.h"
112 #include "gdb_wait.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
;
124 extern int unlink ();
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
;
133 extern char ninStopWhy ();
134 extern int ninMemGet ();
135 extern int ninMemPut ();
137 int nindy_initial_brk
; /* nonzero if want to send an initial BREAK to nindy */
138 int nindy_old_protocol
; /* nonzero if want to use old protocol */
139 char *nindy_ttyname
; /* name of tty to talk to nindy on, or null */
141 #define DLE '\020' /* Character NINDY sends to indicate user program has
146 /* From nindy-share/nindy.c. */
147 extern serial_t nindy_serial
;
149 static int have_regs
= 0; /* 1 iff regs read since i960 last halted */
150 static int regs_changed
= 0; /* 1 iff regs were modified since last read */
152 extern char *exists ();
154 static void nindy_fetch_registers (int);
156 static void nindy_store_registers (int);
158 static char *savename
;
161 nindy_close (int quitting
)
163 if (nindy_serial
!= NULL
)
164 SERIAL_CLOSE (nindy_serial
);
172 /* Open a connection to a remote debugger.
173 FIXME, there should be "set" commands for the options that are
174 now specified with gdb command-line options (old_protocol,
177 nindy_open (char *name
, /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
183 error_no_arg ("serial port device name");
185 target_preopen (from_tty
);
189 have_regs
= regs_changed
= 0;
192 nindy_dcache
= dcache_init (ninMemGet
, ninMemPut
);
194 dcache_flush (nindy_dcache
);
196 /* Allow user to interrupt the following -- we could hang if there's
197 no NINDY at the other end of the remote tty. */
199 /* If baud_rate is -1, then ninConnect will not recognize the baud rate
200 and will deal with the situation in a (more or less) reasonable
202 sprintf (baudrate
, "%d", baud_rate
);
203 ninConnect (name
, baudrate
,
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
);
215 target_fetch_registers (-1);
218 init_wait_for_inferior ();
219 clear_proceed_status ();
223 /* User-initiated quit of nindy operations. */
226 nindy_detach (char *name
, int from_tty
)
229 error ("Too many arguments");
234 nindy_files_info (void)
236 /* FIXME: this lies about the baud rate if we autobauded. */
237 printf_unfiltered ("\tAttached to %s at %d bits per second%s%s.\n", savename
,
239 nindy_old_protocol
? " in old protocol" : "",
240 nindy_initial_brk
? " with initial break" : "");
243 /* Return the number of characters in the buffer before
244 the first DLE character. */
249 char *buf
; /* Character buffer; NOT '\0'-terminated */
250 int n
; /* Number of characters in buffer */
254 for (i
= 0; i
< n
; i
++)
264 /* Tell the remote machine to resume. */
267 nindy_resume (int pid
, int step
, enum target_signal siggnal
)
269 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= stop_signal
)
270 warning ("Can't send signals to remote NINDY targets.");
272 dcache_flush (nindy_dcache
);
275 nindy_store_registers (-1);
282 /* FIXME, we can probably use the normal terminal_inferior stuff here.
283 We have to do terminal_inferior and then set up the passthrough
284 settings initially. Thereafter, terminal_ours and terminal_inferior
285 will automatically swap the settings around for us. */
287 struct clean_up_tty_args
289 serial_ttystate state
;
292 static struct clean_up_tty_args tty_args
;
295 clean_up_tty (PTR ptrarg
)
297 struct clean_up_tty_args
*args
= (struct clean_up_tty_args
*) ptrarg
;
298 SERIAL_SET_TTY_STATE (args
->serial
, args
->state
);
300 warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
303 /* Recover from ^Z or ^C while remote process is running */
304 static void (*old_ctrlc
) ();
306 static void (*old_ctrlz
) ();
312 SERIAL_SET_TTY_STATE (tty_args
.serial
, tty_args
.state
);
313 free (tty_args
.state
);
315 signal (SIGINT
, old_ctrlc
);
317 signal (SIGTSTP
, old_ctrlz
);
319 error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
322 /* Wait until the remote machine stops. While waiting, operate in passthrough
323 * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
326 * Return to caller, storing status in 'status' just as `wait' would.
330 nindy_wait (int pid
, struct target_waitstatus
*status
)
336 unsigned char stop_exit
;
337 unsigned char stop_code
;
338 struct cleanup
*old_cleanups
;
339 long ip_value
, fp_value
, sp_value
; /* Reg values from stop */
341 status
->kind
= TARGET_WAITKIND_EXITED
;
342 status
->value
.integer
= 0;
344 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
346 /* Save current tty attributes, and restore them when done. */
347 tty_args
.serial
= SERIAL_FDOPEN (0);
348 tty_args
.state
= SERIAL_GET_TTY_STATE (tty_args
.serial
);
349 old_ctrlc
= signal (SIGINT
, clean_up_int
);
351 old_ctrlz
= signal (SIGTSTP
, clean_up_int
);
354 old_cleanups
= make_cleanup (clean_up_tty
, &tty_args
);
356 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
357 <CR> and perform echo. */
358 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
360 SERIAL_RAW (tty_args
.serial
);
364 /* Input on remote */
365 c
= SERIAL_READCHAR (nindy_serial
, -1);
366 if (c
== SERIAL_ERROR
)
368 error ("Cannot read from serial line");
370 else if (c
== 0x1b) /* ESC */
372 c
= SERIAL_READCHAR (nindy_serial
, -1);
375 else if (c
!= 0x10) /* DLE */
376 /* Write out any characters preceding DLE */
383 stop_exit
= ninStopWhy (&stop_code
,
384 &ip_value
, &fp_value
, &sp_value
);
385 if (!stop_exit
&& (stop_code
== STOP_SRQ
))
393 /* Get out of loop */
394 supply_register (IP_REGNUM
,
396 supply_register (FP_REGNUM
,
398 supply_register (SP_REGNUM
,
405 SERIAL_SET_TTY_STATE (tty_args
.serial
, tty_args
.state
);
406 free (tty_args
.state
);
407 discard_cleanups (old_cleanups
);
411 status
->kind
= TARGET_WAITKIND_EXITED
;
412 status
->value
.integer
= stop_code
;
416 /* nindy has some special stop code need to be handled */
417 if (stop_code
== STOP_GDB_BPT
)
418 stop_code
= TRACE_STEP
;
419 status
->kind
= TARGET_WAITKIND_STOPPED
;
420 status
->value
.sig
= i960_fault_to_signal (stop_code
);
425 /* Read the remote registers into the block REGS. */
427 /* This is the block that ninRegsGet and ninRegsPut handles. */
430 char local_regs
[16 * 4];
431 char global_regs
[16 * 4];
435 char fp_as_double
[4 * 8];
439 nindy_fetch_registers (int regno
)
441 struct nindy_regs nindy_regs
;
445 ninRegsGet ((char *) &nindy_regs
);
448 memcpy (®isters
[REGISTER_BYTE (R0_REGNUM
)], nindy_regs
.local_regs
, 16 * 4);
449 memcpy (®isters
[REGISTER_BYTE (G0_REGNUM
)], nindy_regs
.global_regs
, 16 * 4);
450 memcpy (®isters
[REGISTER_BYTE (PCW_REGNUM
)], nindy_regs
.pcw_acw
, 2 * 4);
451 memcpy (®isters
[REGISTER_BYTE (IP_REGNUM
)], nindy_regs
.ip
, 1 * 4);
452 memcpy (®isters
[REGISTER_BYTE (TCW_REGNUM
)], nindy_regs
.tcw
, 1 * 4);
453 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], nindy_regs
.fp_as_double
, 4 * 8);
455 registers_fetched ();
459 nindy_prepare_to_store (void)
461 /* Fetch all regs if they aren't already here. */
462 read_register_bytes (0, NULL
, REGISTER_BYTES
);
466 nindy_store_registers (int regno
)
468 struct nindy_regs nindy_regs
;
471 memcpy (nindy_regs
.local_regs
, ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16 * 4);
472 memcpy (nindy_regs
.global_regs
, ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16 * 4);
473 memcpy (nindy_regs
.pcw_acw
, ®isters
[REGISTER_BYTE (PCW_REGNUM
)], 2 * 4);
474 memcpy (nindy_regs
.ip
, ®isters
[REGISTER_BYTE (IP_REGNUM
)], 1 * 4);
475 memcpy (nindy_regs
.tcw
, ®isters
[REGISTER_BYTE (TCW_REGNUM
)], 1 * 4);
476 memcpy (nindy_regs
.fp_as_double
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)], 8 * 4);
479 ninRegsPut ((char *) &nindy_regs
);
483 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
484 to debugger memory starting at MYADDR. Copy to inferior if
485 SHOULD_WRITE is nonzero. Returns the length copied. */
488 nindy_xfer_inferior_memory (memaddr
, myaddr
, len
, should_write
, target
)
493 struct target_ops
*target
; /* ignored */
497 return dcache_xfer_memory (nindy_dcache
, memaddr
, myaddr
,
502 nindy_create_inferior (char *execfile
, char *args
, char **env
)
508 error ("Can't pass arguments to remote NINDY process");
510 if (execfile
== 0 || exec_bfd
== 0)
511 error ("No executable file specified");
513 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
517 /* The "process" (board) is already stopped awaiting our commands, and
518 the program is already downloaded. We just set its PC and go. */
520 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
522 clear_proceed_status ();
524 /* Tell wait_for_inferior that we've started a new process. */
525 init_wait_for_inferior ();
527 /* Set up the "saved terminal modes" of the inferior
528 based on what modes we are starting it with. */
529 target_terminal_init ();
531 /* Install inferior's terminal modes. */
532 target_terminal_inferior ();
534 /* insert_step_breakpoint (); FIXME, do we need this? */
536 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
540 reset_command (char *args
, int from_tty
)
542 if (nindy_serial
== NULL
)
544 error ("No target system to reset -- use 'target nindy' command.");
546 if (query ("Really reset the target system?", 0, 0))
548 SERIAL_SEND_BREAK (nindy_serial
);
549 tty_flush (nindy_serial
);
554 nindy_kill (char *args
, int from_tty
)
556 return; /* Ignore attempts to kill target system */
559 /* Clean up when a program exits.
561 The program actually lives on in the remote processor's RAM, and may be
562 run again without a download. Don't leave it full of breakpoint
566 nindy_mourn_inferior (void)
568 remove_breakpoints ();
569 unpush_target (&nindy_ops
);
570 generic_mourn_inferior (); /* Do all the proper things now */
573 /* Pass the args the way catch_errors wants them. */
575 nindy_open_stub (char *arg
)
582 nindy_load (char *filename
, int from_tty
)
585 /* Can't do unix style forking on a VMS system, so we'll use bfd to do
589 bfd
*file
= bfd_openr (filename
, 0);
592 perror_with_name (filename
);
596 if (!bfd_check_format (file
, bfd_object
))
598 error ("can't prove it's an object file\n");
602 for (s
= file
->sections
; s
; s
= s
->next
)
604 if (s
->flags
& SEC_LOAD
)
606 char *buffer
= xmalloc (s
->_raw_size
);
607 bfd_get_section_contents (file
, s
, buffer
, 0, s
->_raw_size
);
608 printf ("Loading section %s, size %x vma %x\n",
612 ninMemPut (s
->vma
, buffer
, s
->_raw_size
);
620 load_stub (char *arg
)
622 target_load (arg
, 1);
626 /* This routine is run as a hook, just before the main command loop is
627 entered. If gdb is configured for the i960, but has not had its
628 nindy target specified yet, this will loop prompting the user to do so.
630 Unlike the loop provided by Intel, we actually let the user get out
631 of this with a RETURN. This is useful when e.g. simply examining
632 an i960 object file on the host system. */
635 nindy_before_main_loop (void)
640 while (target_stack
->target_ops
!= &nindy_ops
) /* What is this crap??? */
641 { /* remote tty not specified yet */
642 if (instream
== stdin
)
644 printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
645 gdb_flush (gdb_stdout
);
647 fgets (ttyname
, sizeof (ttyname
) - 1, stdin
);
649 /* Strip leading and trailing whitespace */
650 for (p
= ttyname
; isspace (*p
); p
++)
656 return; /* User just hit spaces or return, wants out */
658 for (p2
= p
; !isspace (*p2
) && (*p2
!= '\0'); p2
++)
663 if (STREQ ("quit", p
))
668 if (catch_errors (nindy_open_stub
, p
, "", RETURN_MASK_ALL
))
670 /* Now that we have a tty open for talking to the remote machine,
671 download the executable file if one was specified. */
674 catch_errors (load_stub
, bfd_get_filename (exec_bfd
), "",
681 /* Define the target subroutine names */
683 struct target_ops nindy_ops
;
686 init_nindy_ops (void)
688 nindy_ops
.to_shortname
= "nindy";
689 "Remote serial target in i960 NINDY-specific protocol",
690 nindy_ops
.to_longname
= "Use a remote i960 system running NINDY connected by a serial line.\n\
691 Specify the name of the device the serial line is connected to.\n\
692 The speed (baud rate), whether to use the old NINDY protocol,\n\
693 and whether to send a break on startup, are controlled by options\n\
694 specified when you started GDB.";
695 nindy_ops
.to_doc
= "";
696 nindy_ops
.to_open
= nindy_open
;
697 nindy_ops
.to_close
= nindy_close
;
698 nindy_ops
.to_attach
= 0;
699 nindy_ops
.to_post_attach
= NULL
;
700 nindy_ops
.to_require_attach
= NULL
;
701 nindy_ops
.to_detach
= nindy_detach
;
702 nindy_ops
.to_require_detach
= NULL
;
703 nindy_ops
.to_resume
= nindy_resume
;
704 nindy_ops
.to_wait
= nindy_wait
;
705 nindy_ops
.to_post_wait
= NULL
;
706 nindy_ops
.to_fetch_registers
= nindy_fetch_registers
;
707 nindy_ops
.to_store_registers
= nindy_store_registers
;
708 nindy_ops
.to_prepare_to_store
= nindy_prepare_to_store
;
709 nindy_ops
.to_xfer_memory
= nindy_xfer_inferior_memory
;
710 nindy_ops
.to_files_info
= nindy_files_info
;
711 nindy_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
712 nindy_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
713 nindy_ops
.to_terminal_init
= 0;
714 nindy_ops
.to_terminal_inferior
= 0;
715 nindy_ops
.to_terminal_ours_for_output
= 0;
716 nindy_ops
.to_terminal_ours
= 0;
717 nindy_ops
.to_terminal_info
= 0; /* Terminal crud */
718 nindy_ops
.to_kill
= nindy_kill
;
719 nindy_ops
.to_load
= nindy_load
;
720 nindy_ops
.to_lookup_symbol
= 0; /* lookup_symbol */
721 nindy_ops
.to_create_inferior
= nindy_create_inferior
;
722 nindy_ops
.to_post_startup_inferior
= NULL
;
723 nindy_ops
.to_acknowledge_created_inferior
= NULL
;
724 nindy_ops
.to_clone_and_follow_inferior
= NULL
;
725 nindy_ops
.to_post_follow_inferior_by_clone
= NULL
;
726 nindy_ops
.to_insert_fork_catchpoint
= NULL
;
727 nindy_ops
.to_remove_fork_catchpoint
= NULL
;
728 nindy_ops
.to_insert_vfork_catchpoint
= NULL
;
729 nindy_ops
.to_remove_vfork_catchpoint
= NULL
;
730 nindy_ops
.to_has_forked
= NULL
;
731 nindy_ops
.to_has_vforked
= NULL
;
732 nindy_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
733 nindy_ops
.to_post_follow_vfork
= NULL
;
734 nindy_ops
.to_insert_exec_catchpoint
= NULL
;
735 nindy_ops
.to_remove_exec_catchpoint
= NULL
;
736 nindy_ops
.to_has_execd
= NULL
;
737 nindy_ops
.to_reported_exec_events_per_exec_call
= NULL
;
738 nindy_ops
.to_has_exited
= NULL
;
739 nindy_ops
.to_mourn_inferior
= nindy_mourn_inferior
;
740 nindy_ops
.to_can_run
= 0; /* can_run */
741 nindy_ops
.to_notice_signals
= 0; /* notice_signals */
742 nindy_ops
.to_thread_alive
= 0; /* to_thread_alive */
743 nindy_ops
.to_stop
= 0; /* to_stop */
744 nindy_ops
.to_pid_to_exec_file
= NULL
;
745 nindy_ops
.to_core_file_to_sym_file
= NULL
;
746 nindy_ops
.to_stratum
= process_stratum
;
747 nindy_ops
.DONT_USE
= 0; /* next */
748 nindy_ops
.to_has_all_memory
= 1;
749 nindy_ops
.to_has_memory
= 1;
750 nindy_ops
.to_has_stack
= 1;
751 nindy_ops
.to_has_registers
= 1;
752 nindy_ops
.to_has_execution
= 1; /* all mem, mem, stack, regs, exec */
753 nindy_ops
.to_sections
= 0;
754 nindy_ops
.to_sections_end
= 0; /* Section pointers */
755 nindy_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
759 _initialize_nindy (void)
762 add_target (&nindy_ops
);
763 add_com ("reset", class_obscure
, reset_command
,
764 "Send a 'break' to the remote target system.\n\
765 Only useful if the target has been equipped with a circuit\n\
766 to perform a hard reset when a break is detected.");