1 /* Memory-access and commands for remote NINDY process, for GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999,
4 2000, 2001, 2002 Free Software Foundation, Inc.
6 Contributed by Intel Corporation. Modified from remote.c by Chris Benenati.
8 GDB is distributed in the hope that it will be useful, but WITHOUT ANY
9 WARRANTY. No author or distributor accepts responsibility to anyone
10 for the consequences of using it or for whether it serves any
11 particular purpose or works at all, unless he says so in writing.
12 Refer to the GDB General Public License for full details.
14 Everyone is granted permission to copy, modify and redistribute GDB,
15 but only under the conditions described in the GDB General Public
16 License. A copy of this license is supposed to have been given to you
17 along with GDB so you can know your rights and responsibilities. It
18 should be in a file named COPYING. Among other things, the copyright
19 notice and this notice must be preserved on all copies.
21 In other words, go ahead and share GDB, but don't try to stop
22 anyone else from sharing it farther. Help stamp out software hoarding! */
25 Except for the data cache routines, this file bears little resemblence
26 to remote.c. A new (although similar) protocol has been specified, and
27 portions of the code are entirely dependent on having an i80960 with a
28 NINDY ROM monitor at the other end of the line.
31 /*****************************************************************************
33 * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR.
39 * As far as NINDY is concerned, GDB is always in one of two modes: command
40 * mode or passthrough mode.
42 * In command mode (the default) pre-defined packets containing requests
43 * are sent by GDB to NINDY. NINDY never talks except in reponse to a request.
45 * Once the the user program is started, GDB enters passthrough mode, to give
46 * the user program access to the terminal. GDB remains in this mode until
47 * NINDY indicates that the program has stopped.
53 * GDB writes all input received from the keyboard directly to NINDY, and writes
54 * all characters received from NINDY directly to the monitor.
56 * Keyboard input is neither buffered nor echoed to the monitor.
58 * GDB remains in passthrough mode until NINDY sends a single ^P character,
59 * to indicate that the user process has stopped.
62 * GDB assumes NINDY performs a 'flushreg' when the user program stops.
68 * All info (except for message ack and nak) is transferred between gdb
69 * and the remote processor in messages of the following format:
74 * # is a literal character
76 * <info> ASCII information; all numeric information is in the
77 * form of hex digits ('0'-'9' and lowercase 'a'-'f').
80 * is a pair of ASCII hex digits representing an 8-bit
81 * checksum formed by adding together each of the
82 * characters in <info>.
84 * The receiver of a message always sends a single character to the sender
85 * to indicate that the checksum was good ('+') or bad ('-'); the sender
86 * re-transmits the entire message over until a '+' is received.
88 * In response to a command NINDY always sends back either data or
89 * a result code of the form "Xnn", where "nn" are hex digits and "X00"
90 * means no errors. (Exceptions: the "s" and "c" commands don't respond.)
92 * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A
93 * FULL DESCRIPTION OF LEGAL COMMANDS.
95 * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST
98 ***************************************************************************/
102 #include <sys/types.h>
106 #include "inferior.h"
112 #include "floatformat.h"
113 #include "regcache.h"
115 #include <sys/file.h>
118 #include "nindy-share/env.h"
119 #include "nindy-share/stop.h"
120 #include "remote-utils.h"
122 extern int unlink ();
123 extern char *getenv ();
124 extern char *mktemp ();
126 extern void generic_mourn_inferior ();
128 extern struct target_ops nindy_ops
;
129 extern FILE *instream
;
131 extern char ninStopWhy ();
132 extern int ninMemGet ();
133 extern int ninMemPut ();
135 int nindy_initial_brk
; /* nonzero if want to send an initial BREAK to nindy */
136 int nindy_old_protocol
; /* nonzero if want to use old protocol */
137 char *nindy_ttyname
; /* name of tty to talk to nindy on, or null */
139 #define DLE '\020' /* Character NINDY sends to indicate user program has
144 /* From nindy-share/nindy.c. */
145 extern struct serial
*nindy_serial
;
147 static int have_regs
= 0; /* 1 iff regs read since i960 last halted */
148 static int regs_changed
= 0; /* 1 iff regs were modified since last read */
150 extern char *exists ();
152 static void nindy_fetch_registers (int);
154 static void nindy_store_registers (int);
156 static char *savename
;
159 nindy_close (int quitting
)
161 if (nindy_serial
!= NULL
)
162 serial_close (nindy_serial
);
170 /* Open a connection to a remote debugger.
171 FIXME, there should be "set" commands for the options that are
172 now specified with gdb command-line options (old_protocol,
175 nindy_open (char *name
, /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
181 error_no_arg ("serial port device name");
183 target_preopen (from_tty
);
187 have_regs
= regs_changed
= 0;
189 /* Allow user to interrupt the following -- we could hang if there's
190 no NINDY at the other end of the remote tty. */
192 /* If baud_rate is -1, then ninConnect will not recognize the baud rate
193 and will deal with the situation in a (more or less) reasonable
195 sprintf (baudrate
, "%d", baud_rate
);
196 ninConnect (name
, baudrate
,
197 nindy_initial_brk
, !from_tty
, nindy_old_protocol
);
200 if (nindy_serial
== NULL
)
202 perror_with_name (name
);
205 savename
= savestring (name
, strlen (name
));
206 push_target (&nindy_ops
);
208 target_fetch_registers (-1);
211 init_wait_for_inferior ();
212 clear_proceed_status ();
216 /* User-initiated quit of nindy operations. */
219 nindy_detach (char *name
, int from_tty
)
222 error ("Too many arguments");
227 nindy_files_info (void)
229 /* FIXME: this lies about the baud rate if we autobauded. */
230 printf_unfiltered ("\tAttached to %s at %d bits per second%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 BUF before
237 the first DLE character. N is maximum number of characters to
242 non_dle (char *buf
, int n
)
246 for (i
= 0; i
< n
; i
++)
256 /* Tell the remote machine to resume. */
259 nindy_resume (ptid_t ptid
, int step
, enum target_signal siggnal
)
261 if (siggnal
!= TARGET_SIGNAL_0
&& siggnal
!= stop_signal
)
262 warning ("Can't send signals to remote NINDY targets.");
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
280 serial_ttystate state
;
281 struct serial
*serial
;
283 static struct clean_up_tty_args tty_args
;
286 clean_up_tty (PTR ptrarg
)
288 struct clean_up_tty_args
*args
= (struct clean_up_tty_args
*) ptrarg
;
289 serial_set_tty_state (args
->serial
, args
->state
);
291 warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
294 /* Recover from ^Z or ^C while remote process is running */
295 static void (*old_ctrlc
) ();
297 static void (*old_ctrlz
) ();
303 serial_set_tty_state (tty_args
.serial
, tty_args
.state
);
304 xfree (tty_args
.state
);
306 signal (SIGINT
, old_ctrlc
);
308 signal (SIGTSTP
, old_ctrlz
);
310 error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
313 /* Wait until the remote machine stops. While waiting, operate in passthrough
314 * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
317 * Return to caller, storing status in 'status' just as `wait' would.
321 nindy_wait (ptid_t ptid
, struct target_waitstatus
*status
)
327 unsigned char stop_exit
;
328 unsigned char stop_code
;
329 struct cleanup
*old_cleanups
;
330 long ip_value
, fp_value
, sp_value
; /* Reg values from stop */
332 status
->kind
= TARGET_WAITKIND_EXITED
;
333 status
->value
.integer
= 0;
335 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
337 /* Save current tty attributes, and restore them when done. */
338 tty_args
.serial
= serial_fdopen (0);
339 tty_args
.state
= serial_get_tty_state (tty_args
.serial
);
340 old_ctrlc
= signal (SIGINT
, clean_up_int
);
342 old_ctrlz
= signal (SIGTSTP
, clean_up_int
);
345 old_cleanups
= make_cleanup (clean_up_tty
, &tty_args
);
347 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
348 <CR> and perform echo. */
349 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
351 serial_raw (tty_args
.serial
);
355 /* Input on remote */
356 c
= serial_readchar (nindy_serial
, -1);
357 if (c
== SERIAL_ERROR
)
359 error ("Cannot read from serial line");
361 else if (c
== 0x1b) /* ESC */
363 c
= serial_readchar (nindy_serial
, -1);
366 else if (c
!= 0x10) /* DLE */
367 /* Write out any characters preceding DLE */
374 stop_exit
= ninStopWhy (&stop_code
,
375 &ip_value
, &fp_value
, &sp_value
);
376 if (!stop_exit
&& (stop_code
== STOP_SRQ
))
384 /* Get out of loop */
385 supply_register (IP_REGNUM
,
387 supply_register (FP_REGNUM
,
389 supply_register (SP_REGNUM
,
396 serial_set_tty_state (tty_args
.serial
, tty_args
.state
);
397 xfree (tty_args
.state
);
398 discard_cleanups (old_cleanups
);
402 status
->kind
= TARGET_WAITKIND_EXITED
;
403 status
->value
.integer
= stop_code
;
407 /* nindy has some special stop code need to be handled */
408 if (stop_code
== STOP_GDB_BPT
)
409 stop_code
= TRACE_STEP
;
410 status
->kind
= TARGET_WAITKIND_STOPPED
;
411 status
->value
.sig
= i960_fault_to_signal (stop_code
);
413 return inferior_ptid
;
416 /* Read the remote registers into the block REGS. */
418 /* This is the block that ninRegsGet and ninRegsPut handles. */
421 char local_regs
[16 * 4];
422 char global_regs
[16 * 4];
426 char fp_as_double
[4 * 8];
430 nindy_fetch_registers (int regno
)
432 struct nindy_regs nindy_regs
;
436 ninRegsGet ((char *) &nindy_regs
);
439 memcpy (®isters
[REGISTER_BYTE (R0_REGNUM
)], nindy_regs
.local_regs
, 16 * 4);
440 memcpy (®isters
[REGISTER_BYTE (G0_REGNUM
)], nindy_regs
.global_regs
, 16 * 4);
441 memcpy (®isters
[REGISTER_BYTE (PCW_REGNUM
)], nindy_regs
.pcw_acw
, 2 * 4);
442 memcpy (®isters
[REGISTER_BYTE (IP_REGNUM
)], nindy_regs
.ip
, 1 * 4);
443 memcpy (®isters
[REGISTER_BYTE (TCW_REGNUM
)], nindy_regs
.tcw
, 1 * 4);
444 memcpy (®isters
[REGISTER_BYTE (FP0_REGNUM
)], nindy_regs
.fp_as_double
, 4 * 8);
446 registers_fetched ();
450 nindy_prepare_to_store (void)
452 /* Fetch all regs if they aren't already here. */
453 read_register_bytes (0, NULL
, REGISTER_BYTES
);
457 nindy_store_registers (int regno
)
459 struct nindy_regs nindy_regs
;
462 memcpy (nindy_regs
.local_regs
, ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16 * 4);
463 memcpy (nindy_regs
.global_regs
, ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16 * 4);
464 memcpy (nindy_regs
.pcw_acw
, ®isters
[REGISTER_BYTE (PCW_REGNUM
)], 2 * 4);
465 memcpy (nindy_regs
.ip
, ®isters
[REGISTER_BYTE (IP_REGNUM
)], 1 * 4);
466 memcpy (nindy_regs
.tcw
, ®isters
[REGISTER_BYTE (TCW_REGNUM
)], 1 * 4);
467 memcpy (nindy_regs
.fp_as_double
, ®isters
[REGISTER_BYTE (FP0_REGNUM
)], 8 * 4);
470 ninRegsPut ((char *) &nindy_regs
);
474 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
475 to debugger memory starting at MYADDR. Copy to inferior if
476 SHOULD_WRITE is nonzero. Returns the length copied. TARGET is
480 nindy_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
481 int should_write
, struct mem_attrib
*attrib
,
482 struct target_ops
*target
)
490 res
= ninMemPut (memaddr
, myaddr
, len
);
492 res
= ninMemGet (memaddr
, myaddr
, len
);
498 nindy_create_inferior (char *execfile
, char *args
, char **env
)
504 error ("Can't pass arguments to remote NINDY process");
506 if (execfile
== 0 || exec_bfd
== 0)
507 error ("No executable file specified");
509 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
513 /* The "process" (board) is already stopped awaiting our commands, and
514 the program is already downloaded. We just set its PC and go. */
516 inferior_ptid
= pid_to_ptid (pid
); /* Needed for wait_for_inferior below */
518 clear_proceed_status ();
520 /* Tell wait_for_inferior that we've started a new process. */
521 init_wait_for_inferior ();
523 /* Set up the "saved terminal modes" of the inferior
524 based on what modes we are starting it with. */
525 target_terminal_init ();
527 /* Install inferior's terminal modes. */
528 target_terminal_inferior ();
530 /* insert_step_breakpoint (); FIXME, do we need this? */
532 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
536 reset_command (char *args
, int from_tty
)
538 if (nindy_serial
== NULL
)
540 error ("No target system to reset -- use 'target nindy' command.");
542 if (query ("Really reset the target system?", 0, 0))
544 serial_send_break (nindy_serial
);
545 tty_flush (nindy_serial
);
550 nindy_kill (char *args
, int from_tty
)
552 return; /* Ignore attempts to kill target system */
555 /* Clean up when a program exits.
557 The program actually lives on in the remote processor's RAM, and may be
558 run again without a download. Don't leave it full of breakpoint
562 nindy_mourn_inferior (void)
564 remove_breakpoints ();
565 unpush_target (&nindy_ops
);
566 generic_mourn_inferior (); /* Do all the proper things now */
569 /* Pass the args the way catch_errors wants them. */
571 nindy_open_stub (char *arg
)
578 nindy_load (char *filename
, int from_tty
)
581 /* Can't do unix style forking on a VMS system, so we'll use bfd to do
585 bfd
*file
= bfd_openr (filename
, 0);
588 perror_with_name (filename
);
592 if (!bfd_check_format (file
, bfd_object
))
594 error ("can't prove it's an object file\n");
598 for (s
= file
->sections
; s
; s
= s
->next
)
600 if (s
->flags
& SEC_LOAD
)
602 char *buffer
= xmalloc (s
->_raw_size
);
603 bfd_get_section_contents (file
, s
, buffer
, 0, s
->_raw_size
);
604 printf ("Loading section %s, size %x vma %x\n",
608 ninMemPut (s
->vma
, buffer
, s
->_raw_size
);
616 load_stub (char *arg
)
618 target_load (arg
, 1);
622 /* This routine is run as a hook, just before the main command loop is
623 entered. If gdb is configured for the i960, but has not had its
624 nindy target specified yet, this will loop prompting the user to do so.
626 Unlike the loop provided by Intel, we actually let the user get out
627 of this with a RETURN. This is useful when e.g. simply examining
628 an i960 object file on the host system. */
631 nindy_before_main_loop (void)
636 while (target_stack
->target_ops
!= &nindy_ops
) /* What is this crap??? */
637 { /* remote tty not specified yet */
638 if (instream
== stdin
)
640 printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
641 gdb_flush (gdb_stdout
);
643 fgets (ttyname
, sizeof (ttyname
) - 1, stdin
);
645 /* Strip leading and trailing whitespace */
646 for (p
= ttyname
; isspace (*p
); p
++)
652 return; /* User just hit spaces or return, wants out */
654 for (p2
= p
; !isspace (*p2
) && (*p2
!= '\0'); p2
++)
659 if (STREQ ("quit", p
))
664 if (catch_errors (nindy_open_stub
, p
, "", RETURN_MASK_ALL
))
666 /* Now that we have a tty open for talking to the remote machine,
667 download the executable file if one was specified. */
670 catch_errors (load_stub
, bfd_get_filename (exec_bfd
), "",
677 /* Define the target subroutine names */
679 struct target_ops nindy_ops
;
682 init_nindy_ops (void)
684 nindy_ops
.to_shortname
= "nindy";
685 "Remote serial target in i960 NINDY-specific protocol",
686 nindy_ops
.to_longname
= "Use a remote i960 system running NINDY connected by a serial line.\n\
687 Specify the name of the device the serial line is connected to.\n\
688 The speed (baud rate), whether to use the old NINDY protocol,\n\
689 and whether to send a break on startup, are controlled by options\n\
690 specified when you started GDB.";
691 nindy_ops
.to_doc
= "";
692 nindy_ops
.to_open
= nindy_open
;
693 nindy_ops
.to_close
= nindy_close
;
694 nindy_ops
.to_attach
= 0;
695 nindy_ops
.to_post_attach
= NULL
;
696 nindy_ops
.to_require_attach
= NULL
;
697 nindy_ops
.to_detach
= nindy_detach
;
698 nindy_ops
.to_require_detach
= NULL
;
699 nindy_ops
.to_resume
= nindy_resume
;
700 nindy_ops
.to_wait
= nindy_wait
;
701 nindy_ops
.to_post_wait
= NULL
;
702 nindy_ops
.to_fetch_registers
= nindy_fetch_registers
;
703 nindy_ops
.to_store_registers
= nindy_store_registers
;
704 nindy_ops
.to_prepare_to_store
= nindy_prepare_to_store
;
705 nindy_ops
.to_xfer_memory
= nindy_xfer_inferior_memory
;
706 nindy_ops
.to_files_info
= nindy_files_info
;
707 nindy_ops
.to_insert_breakpoint
= memory_insert_breakpoint
;
708 nindy_ops
.to_remove_breakpoint
= memory_remove_breakpoint
;
709 nindy_ops
.to_terminal_init
= 0;
710 nindy_ops
.to_terminal_inferior
= 0;
711 nindy_ops
.to_terminal_ours_for_output
= 0;
712 nindy_ops
.to_terminal_ours
= 0;
713 nindy_ops
.to_terminal_info
= 0; /* Terminal crud */
714 nindy_ops
.to_kill
= nindy_kill
;
715 nindy_ops
.to_load
= nindy_load
;
716 nindy_ops
.to_lookup_symbol
= 0; /* lookup_symbol */
717 nindy_ops
.to_create_inferior
= nindy_create_inferior
;
718 nindy_ops
.to_post_startup_inferior
= NULL
;
719 nindy_ops
.to_acknowledge_created_inferior
= NULL
;
720 nindy_ops
.to_clone_and_follow_inferior
= NULL
;
721 nindy_ops
.to_post_follow_inferior_by_clone
= NULL
;
722 nindy_ops
.to_insert_fork_catchpoint
= NULL
;
723 nindy_ops
.to_remove_fork_catchpoint
= NULL
;
724 nindy_ops
.to_insert_vfork_catchpoint
= NULL
;
725 nindy_ops
.to_remove_vfork_catchpoint
= NULL
;
726 nindy_ops
.to_has_forked
= NULL
;
727 nindy_ops
.to_has_vforked
= NULL
;
728 nindy_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
729 nindy_ops
.to_post_follow_vfork
= NULL
;
730 nindy_ops
.to_insert_exec_catchpoint
= NULL
;
731 nindy_ops
.to_remove_exec_catchpoint
= NULL
;
732 nindy_ops
.to_has_execd
= NULL
;
733 nindy_ops
.to_reported_exec_events_per_exec_call
= NULL
;
734 nindy_ops
.to_has_exited
= NULL
;
735 nindy_ops
.to_mourn_inferior
= nindy_mourn_inferior
;
736 nindy_ops
.to_can_run
= 0; /* can_run */
737 nindy_ops
.to_notice_signals
= 0; /* notice_signals */
738 nindy_ops
.to_thread_alive
= 0; /* to_thread_alive */
739 nindy_ops
.to_stop
= 0; /* to_stop */
740 nindy_ops
.to_pid_to_exec_file
= NULL
;
741 nindy_ops
.to_stratum
= process_stratum
;
742 nindy_ops
.DONT_USE
= 0; /* next */
743 nindy_ops
.to_has_all_memory
= 1;
744 nindy_ops
.to_has_memory
= 1;
745 nindy_ops
.to_has_stack
= 1;
746 nindy_ops
.to_has_registers
= 1;
747 nindy_ops
.to_has_execution
= 1; /* all mem, mem, stack, regs, exec */
748 nindy_ops
.to_sections
= 0;
749 nindy_ops
.to_sections_end
= 0; /* Section pointers */
750 nindy_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
754 _initialize_nindy (void)
757 add_target (&nindy_ops
);
758 add_com ("reset", class_obscure
, reset_command
,
759 "Send a 'break' to the remote target system.\n\
760 Only useful if the target has been equipped with a circuit\n\
761 to perform a hard reset when a break is detected.");