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 (quitting
)
164 if (nindy_serial
!= NULL
)
165 SERIAL_CLOSE (nindy_serial
);
173 /* Open a connection to a remote debugger.
174 FIXME, there should be "set" commands for the options that are
175 now specified with gdb command-line options (old_protocol,
178 nindy_open (name
, from_tty
)
179 char *name
; /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
185 error_no_arg ("serial port device name");
187 target_preopen (from_tty
);
191 have_regs
= regs_changed
= 0;
192 nindy_dcache
= dcache_init (ninMemGet
, ninMemPut
);
194 /* Allow user to interrupt the following -- we could hang if there's
195 no NINDY at the other end of the remote tty. */
197 /* If baud_rate is -1, then ninConnect will not recognize the baud rate
198 and will deal with the situation in a (more or less) reasonable
200 sprintf (baudrate
, "%d", 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
);
213 target_fetch_registers (-1);
216 init_wait_for_inferior ();
217 clear_proceed_status ();
221 /* User-initiated quit of nindy operations. */
224 nindy_detach (name
, from_tty
)
229 error ("Too many arguments");
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 (pid
, step
, siggnal
)
269 enum target_signal siggnal
;
271 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= stop_signal
)
272 warning ("Can't send signals to remote NINDY targets.");
274 dcache_flush (nindy_dcache
);
277 nindy_store_registers (-1);
284 /* FIXME, we can probably use the normal terminal_inferior stuff here.
285 We have to do terminal_inferior and then set up the passthrough
286 settings initially. Thereafter, terminal_ours and terminal_inferior
287 will automatically swap the settings around for us. */
289 struct clean_up_tty_args
291 serial_ttystate state
;
294 static struct clean_up_tty_args tty_args
;
297 clean_up_tty (ptrarg
)
300 struct clean_up_tty_args
*args
= (struct clean_up_tty_args
*) ptrarg
;
301 SERIAL_SET_TTY_STATE (args
->serial
, args
->state
);
303 warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
306 /* Recover from ^Z or ^C while remote process is running */
307 static void (*old_ctrlc
) ();
309 static void (*old_ctrlz
) ();
315 SERIAL_SET_TTY_STATE (tty_args
.serial
, tty_args
.state
);
316 free (tty_args
.state
);
318 signal (SIGINT
, old_ctrlc
);
320 signal (SIGTSTP
, old_ctrlz
);
322 error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
325 /* Wait until the remote machine stops. While waiting, operate in passthrough
326 * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
329 * Return to caller, storing status in 'status' just as `wait' would.
333 nindy_wait (pid
, status
)
335 struct target_waitstatus
*status
;
341 unsigned char stop_exit
;
342 unsigned char stop_code
;
343 struct cleanup
*old_cleanups
;
344 long ip_value
, fp_value
, sp_value
; /* Reg values from stop */
346 status
->kind
= TARGET_WAITKIND_EXITED
;
347 status
->value
.integer
= 0;
349 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
351 /* Save current tty attributes, and restore them when done. */
352 tty_args
.serial
= SERIAL_FDOPEN (0);
353 tty_args
.state
= SERIAL_GET_TTY_STATE (tty_args
.serial
);
354 old_ctrlc
= signal (SIGINT
, clean_up_int
);
356 old_ctrlz
= signal (SIGTSTP
, clean_up_int
);
359 old_cleanups
= make_cleanup (clean_up_tty
, &tty_args
);
361 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
362 <CR> and perform echo. */
363 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
365 SERIAL_RAW (tty_args
.serial
);
369 /* Input on remote */
370 c
= SERIAL_READCHAR (nindy_serial
, -1);
371 if (c
== SERIAL_ERROR
)
373 error ("Cannot read from serial line");
375 else if (c
== 0x1b) /* ESC */
377 c
= SERIAL_READCHAR (nindy_serial
, -1);
380 else if (c
!= 0x10) /* DLE */
381 /* Write out any characters preceding DLE */
388 stop_exit
= ninStopWhy (&stop_code
,
389 &ip_value
, &fp_value
, &sp_value
);
390 if (!stop_exit
&& (stop_code
== STOP_SRQ
))
398 /* Get out of loop */
399 supply_register (IP_REGNUM
,
401 supply_register (FP_REGNUM
,
403 supply_register (SP_REGNUM
,
410 SERIAL_SET_TTY_STATE (tty_args
.serial
, tty_args
.state
);
411 free (tty_args
.state
);
412 discard_cleanups (old_cleanups
);
416 status
->kind
= TARGET_WAITKIND_EXITED
;
417 status
->value
.integer
= stop_code
;
421 /* nindy has some special stop code need to be handled */
422 if (stop_code
== STOP_GDB_BPT
)
423 stop_code
= TRACE_STEP
;
424 status
->kind
= TARGET_WAITKIND_STOPPED
;
425 status
->value
.sig
= i960_fault_to_signal (stop_code
);
430 /* Read the remote registers into the block REGS. */
432 /* This is the block that ninRegsGet and ninRegsPut handles. */
435 char local_regs
[16 * 4];
436 char global_regs
[16 * 4];
440 char fp_as_double
[4 * 8];
444 nindy_fetch_registers (regno
)
447 struct nindy_regs nindy_regs
;
451 ninRegsGet ((char *) &nindy_regs
);
454 memcpy (®isters
[REGISTER_BYTE (R0_REGNUM
)], nindy_regs
.local_regs
, 16 * 4);
455 memcpy (®isters
[REGISTER_BYTE (G0_REGNUM
)], nindy_regs
.global_regs
, 16 * 4);
456 memcpy (®isters
[REGISTER_BYTE (PCW_REGNUM
)], nindy_regs
.pcw_acw
, 2 * 4);
457 memcpy (®isters
[REGISTER_BYTE (IP_REGNUM
)], nindy_regs
.ip
, 1 * 4);
458 memcpy (®isters
[REGISTER_BYTE (TCW_REGNUM
)], nindy_regs
.tcw
, 1 * 4);
459 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], nindy_regs
.fp_as_double
, 4 * 8);
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
;
478 memcpy (nindy_regs
.local_regs
, ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16 * 4);
479 memcpy (nindy_regs
.global_regs
, ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16 * 4);
480 memcpy (nindy_regs
.pcw_acw
, ®isters
[REGISTER_BYTE (PCW_REGNUM
)], 2 * 4);
481 memcpy (nindy_regs
.ip
, ®isters
[REGISTER_BYTE (IP_REGNUM
)], 1 * 4);
482 memcpy (nindy_regs
.tcw
, ®isters
[REGISTER_BYTE (TCW_REGNUM
)], 1 * 4);
483 memcpy (nindy_regs
.fp_as_double
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)], 8 * 4);
486 ninRegsPut ((char *) &nindy_regs
);
490 /* Read a word from remote address ADDR and return it.
491 * This goes through the data cache.
494 nindy_fetch_word (addr
)
497 return dcache_fetch (nindy_dcache
, addr
);
500 /* Write a word WORD into remote address ADDR.
501 This goes through the data cache. */
504 nindy_store_word (addr
, word
)
508 dcache_poke (nindy_dcache
, addr
, word
);
511 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
512 to debugger memory starting at MYADDR. Copy to inferior if
513 WRITE is nonzero. Returns the length copied.
515 This is stolen almost directly from infptrace.c's child_xfer_memory,
516 which also deals with a word-oriented memory interface. Sometime,
517 FIXME, rewrite this to not use the word-oriented routines. */
520 nindy_xfer_inferior_memory (memaddr
, myaddr
, len
, should_write
, target
)
525 struct target_ops
*target
; /* ignored */
528 /* Round starting address down to longword boundary. */
529 register CORE_ADDR addr
= memaddr
& -sizeof (int);
530 /* Round ending address up; get number of longwords that makes. */
532 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
533 /* Allocate buffer of that many longwords. */
534 register int *buffer
= (int *) alloca (count
* sizeof (int));
538 /* Fill start and end extra bytes of buffer with existing memory data. */
540 if (addr
!= memaddr
|| len
< (int) sizeof (int))
542 /* Need part of initial word -- fetch it. */
543 buffer
[0] = nindy_fetch_word (addr
);
546 if (count
> 1) /* FIXME, avoid if even boundary */
549 = nindy_fetch_word (addr
+ (count
- 1) * sizeof (int));
552 /* Copy data to be written over corresponding part of buffer */
554 memcpy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
556 /* Write the entire buffer. */
558 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
561 nindy_store_word (addr
, buffer
[i
]);
568 /* Read all the longwords */
569 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
572 buffer
[i
] = nindy_fetch_word (addr
);
578 /* Copy appropriate bytes out of the buffer. */
579 memcpy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
585 nindy_create_inferior (execfile
, args
, env
)
594 error ("Can't pass arguments to remote NINDY process");
596 if (execfile
== 0 || exec_bfd
== 0)
597 error ("No executable file specified");
599 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
603 /* The "process" (board) is already stopped awaiting our commands, and
604 the program is already downloaded. We just set its PC and go. */
606 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
608 clear_proceed_status ();
610 /* Tell wait_for_inferior that we've started a new process. */
611 init_wait_for_inferior ();
613 /* Set up the "saved terminal modes" of the inferior
614 based on what modes we are starting it with. */
615 target_terminal_init ();
617 /* Install inferior's terminal modes. */
618 target_terminal_inferior ();
620 /* insert_step_breakpoint (); FIXME, do we need this? */
622 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
626 reset_command (args
, from_tty
)
630 if (nindy_serial
== NULL
)
632 error ("No target system to reset -- use 'target nindy' command.");
634 if (query ("Really reset the target system?", 0, 0))
636 SERIAL_SEND_BREAK (nindy_serial
);
637 tty_flush (nindy_serial
);
642 nindy_kill (args
, from_tty
)
646 return; /* Ignore attempts to kill target system */
649 /* Clean up when a program exits.
651 The program actually lives on in the remote processor's RAM, and may be
652 run again without a download. Don't leave it full of breakpoint
656 nindy_mourn_inferior ()
658 remove_breakpoints ();
659 unpush_target (&nindy_ops
);
660 generic_mourn_inferior (); /* Do all the proper things now */
663 /* Pass the args the way catch_errors wants them. */
665 nindy_open_stub (arg
)
673 nindy_load (filename
, from_tty
)
678 /* Can't do unix style forking on a VMS system, so we'll use bfd to do
682 bfd
*file
= bfd_openr (filename
, 0);
685 perror_with_name (filename
);
689 if (!bfd_check_format (file
, bfd_object
))
691 error ("can't prove it's an object file\n");
695 for (s
= file
->sections
; s
; s
= s
->next
)
697 if (s
->flags
& SEC_LOAD
)
699 char *buffer
= xmalloc (s
->_raw_size
);
700 bfd_get_section_contents (file
, s
, buffer
, 0, s
->_raw_size
);
701 printf ("Loading section %s, size %x vma %x\n",
705 ninMemPut (s
->vma
, buffer
, s
->_raw_size
);
716 target_load (arg
, 1);
720 /* This routine is run as a hook, just before the main command loop is
721 entered. If gdb is configured for the i960, but has not had its
722 nindy target specified yet, this will loop prompting the user to do so.
724 Unlike the loop provided by Intel, we actually let the user get out
725 of this with a RETURN. This is useful when e.g. simply examining
726 an i960 object file on the host system. */
729 nindy_before_main_loop ()
734 while (target_stack
->target_ops
!= &nindy_ops
) /* What is this crap??? */
735 { /* remote tty not specified yet */
736 if (instream
== stdin
)
738 printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
739 gdb_flush (gdb_stdout
);
741 fgets (ttyname
, sizeof (ttyname
) - 1, stdin
);
743 /* Strip leading and trailing whitespace */
744 for (p
= ttyname
; isspace (*p
); p
++)
750 return; /* User just hit spaces or return, wants out */
752 for (p2
= p
; !isspace (*p2
) && (*p2
!= '\0'); p2
++)
757 if (STREQ ("quit", p
))
762 if (catch_errors (nindy_open_stub
, p
, "", RETURN_MASK_ALL
))
764 /* Now that we have a tty open for talking to the remote machine,
765 download the executable file if one was specified. */
768 catch_errors (load_stub
, bfd_get_filename (exec_bfd
), "",
775 /* Define the target subroutine names */
777 struct target_ops nindy_ops
;
780 init_nindy_ops (void)
782 nindy_ops
.to_shortname
= "nindy";
783 "Remote serial target in i960 NINDY-specific protocol",
784 nindy_ops
.to_longname
= "Use a remote i960 system running NINDY connected by a serial line.\n\
785 Specify the name of the device the serial line is connected to.\n\
786 The speed (baud rate), whether to use the old NINDY protocol,\n\
787 and whether to send a break on startup, are controlled by options\n\
788 specified when you started GDB.";
789 nindy_ops
.to_doc
= "";
790 nindy_ops
.to_open
= nindy_open
;
791 nindy_ops
.to_close
= nindy_close
;
792 nindy_ops
.to_attach
= 0;
793 nindy_ops
.to_post_attach
= NULL
;
794 nindy_ops
.to_require_attach
= NULL
;
795 nindy_ops
.to_detach
= nindy_detach
;
796 nindy_ops
.to_require_detach
= NULL
;
797 nindy_ops
.to_resume
= nindy_resume
;
798 nindy_ops
.to_wait
= nindy_wait
;
799 nindy_ops
.to_post_wait
= NULL
;
800 nindy_ops
.to_fetch_registers
= nindy_fetch_registers
;
801 nindy_ops
.to_store_registers
= nindy_store_registers
;
802 nindy_ops
.to_prepare_to_store
= nindy_prepare_to_store
;
803 nindy_ops
.to_xfer_memory
= nindy_xfer_inferior_memory
;
804 nindy_ops
.to_files_info
= nindy_files_info
;
805 nindy_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
806 nindy_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
807 nindy_ops
.to_terminal_init
= 0;
808 nindy_ops
.to_terminal_inferior
= 0;
809 nindy_ops
.to_terminal_ours_for_output
= 0;
810 nindy_ops
.to_terminal_ours
= 0;
811 nindy_ops
.to_terminal_info
= 0; /* Terminal crud */
812 nindy_ops
.to_kill
= nindy_kill
;
813 nindy_ops
.to_load
= nindy_load
;
814 nindy_ops
.to_lookup_symbol
= 0; /* lookup_symbol */
815 nindy_ops
.to_create_inferior
= nindy_create_inferior
;
816 nindy_ops
.to_post_startup_inferior
= NULL
;
817 nindy_ops
.to_acknowledge_created_inferior
= NULL
;
818 nindy_ops
.to_clone_and_follow_inferior
= NULL
;
819 nindy_ops
.to_post_follow_inferior_by_clone
= NULL
;
820 nindy_ops
.to_insert_fork_catchpoint
= NULL
;
821 nindy_ops
.to_remove_fork_catchpoint
= NULL
;
822 nindy_ops
.to_insert_vfork_catchpoint
= NULL
;
823 nindy_ops
.to_remove_vfork_catchpoint
= NULL
;
824 nindy_ops
.to_has_forked
= NULL
;
825 nindy_ops
.to_has_vforked
= NULL
;
826 nindy_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
827 nindy_ops
.to_post_follow_vfork
= NULL
;
828 nindy_ops
.to_insert_exec_catchpoint
= NULL
;
829 nindy_ops
.to_remove_exec_catchpoint
= NULL
;
830 nindy_ops
.to_has_execd
= NULL
;
831 nindy_ops
.to_reported_exec_events_per_exec_call
= NULL
;
832 nindy_ops
.to_has_exited
= NULL
;
833 nindy_ops
.to_mourn_inferior
= nindy_mourn_inferior
;
834 nindy_ops
.to_can_run
= 0; /* can_run */
835 nindy_ops
.to_notice_signals
= 0; /* notice_signals */
836 nindy_ops
.to_thread_alive
= 0; /* to_thread_alive */
837 nindy_ops
.to_stop
= 0; /* to_stop */
838 nindy_ops
.to_pid_to_exec_file
= NULL
;
839 nindy_ops
.to_core_file_to_sym_file
= NULL
;
840 nindy_ops
.to_stratum
= process_stratum
;
841 nindy_ops
.DONT_USE
= 0; /* next */
842 nindy_ops
.to_has_all_memory
= 1;
843 nindy_ops
.to_has_memory
= 1;
844 nindy_ops
.to_has_stack
= 1;
845 nindy_ops
.to_has_registers
= 1;
846 nindy_ops
.to_has_execution
= 1; /* all mem, mem, stack, regs, exec */
847 nindy_ops
.to_sections
= 0;
848 nindy_ops
.to_sections_end
= 0; /* Section pointers */
849 nindy_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
856 add_target (&nindy_ops
);
857 add_com ("reset", class_obscure
, reset_command
,
858 "Send a 'break' to the remote target system.\n\
859 Only useful if the target has been equipped with a circuit\n\
860 to perform a hard reset when a break is detected.");