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_invd (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 BUF before
244 the first DLE character. N is maximum number of characters to
249 non_dle (char *buf, int n)
253 for (i = 0; i < n; i++)
263 /* Tell the remote machine to resume. */
266 nindy_resume (int pid, int step, enum target_signal siggnal)
268 if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
269 warning ("Can't send signals to remote NINDY targets.");
271 dcache_invd (nindy_dcache);
274 nindy_store_registers (-1);
281 /* FIXME, we can probably use the normal terminal_inferior stuff here.
282 We have to do terminal_inferior and then set up the passthrough
283 settings initially. Thereafter, terminal_ours and terminal_inferior
284 will automatically swap the settings around for us. */
286 struct clean_up_tty_args
288 serial_ttystate state;
291 static struct clean_up_tty_args tty_args;
294 clean_up_tty (PTR ptrarg)
296 struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
297 SERIAL_SET_TTY_STATE (args->serial, args->state);
299 warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
302 /* Recover from ^Z or ^C while remote process is running */
303 static void (*old_ctrlc) ();
305 static void (*old_ctrlz) ();
311 SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
312 free (tty_args.state);
314 signal (SIGINT, old_ctrlc);
316 signal (SIGTSTP, old_ctrlz);
318 error ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
321 /* Wait until the remote machine stops. While waiting, operate in passthrough
322 * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
325 * Return to caller, storing status in 'status' just as `wait' would.
329 nindy_wait (int pid, struct target_waitstatus *status)
335 unsigned char stop_exit;
336 unsigned char stop_code;
337 struct cleanup *old_cleanups;
338 long ip_value, fp_value, sp_value; /* Reg values from stop */
340 status->kind = TARGET_WAITKIND_EXITED;
341 status->value.integer = 0;
343 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
345 /* Save current tty attributes, and restore them when done. */
346 tty_args.serial = SERIAL_FDOPEN (0);
347 tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
348 old_ctrlc = signal (SIGINT, clean_up_int);
350 old_ctrlz = signal (SIGTSTP, clean_up_int);
353 old_cleanups = make_cleanup (clean_up_tty, &tty_args);
355 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
356 <CR> and perform echo. */
357 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
359 SERIAL_RAW (tty_args.serial);
363 /* Input on remote */
364 c = SERIAL_READCHAR (nindy_serial, -1);
365 if (c == SERIAL_ERROR)
367 error ("Cannot read from serial line");
369 else if (c == 0x1b) /* ESC */
371 c = SERIAL_READCHAR (nindy_serial, -1);
374 else if (c != 0x10) /* DLE */
375 /* Write out any characters preceding DLE */
382 stop_exit = ninStopWhy (&stop_code,
383 &ip_value, &fp_value, &sp_value);
384 if (!stop_exit && (stop_code == STOP_SRQ))
392 /* Get out of loop */
393 supply_register (IP_REGNUM,
395 supply_register (FP_REGNUM,
397 supply_register (SP_REGNUM,
404 SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
405 free (tty_args.state);
406 discard_cleanups (old_cleanups);
410 status->kind = TARGET_WAITKIND_EXITED;
411 status->value.integer = stop_code;
415 /* nindy has some special stop code need to be handled */
416 if (stop_code == STOP_GDB_BPT)
417 stop_code = TRACE_STEP;
418 status->kind = TARGET_WAITKIND_STOPPED;
419 status->value.sig = i960_fault_to_signal (stop_code);
424 /* Read the remote registers into the block REGS. */
426 /* This is the block that ninRegsGet and ninRegsPut handles. */
429 char local_regs[16 * 4];
430 char global_regs[16 * 4];
434 char fp_as_double[4 * 8];
438 nindy_fetch_registers (int regno)
440 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 memcpy (®isters[REGISTER_BYTE (FP0_REGNUM)], nindy_regs.fp_as_double, 4 * 8);
454 registers_fetched ();
458 nindy_prepare_to_store (void)
460 /* Fetch all regs if they aren't already here. */
461 read_register_bytes (0, NULL, REGISTER_BYTES);
465 nindy_store_registers (int regno)
467 struct nindy_regs nindy_regs;
470 memcpy (nindy_regs.local_regs, ®isters[REGISTER_BYTE (R0_REGNUM)], 16 * 4);
471 memcpy (nindy_regs.global_regs, ®isters[REGISTER_BYTE (G0_REGNUM)], 16 * 4);
472 memcpy (nindy_regs.pcw_acw, ®isters[REGISTER_BYTE (PCW_REGNUM)], 2 * 4);
473 memcpy (nindy_regs.ip, ®isters[REGISTER_BYTE (IP_REGNUM)], 1 * 4);
474 memcpy (nindy_regs.tcw, ®isters[REGISTER_BYTE (TCW_REGNUM)], 1 * 4);
475 memcpy (nindy_regs.fp_as_double, ®isters[REGISTER_BYTE (FP0_REGNUM)], 8 * 4);
478 ninRegsPut ((char *) &nindy_regs);
482 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
483 to debugger memory starting at MYADDR. Copy to inferior if
484 SHOULD_WRITE is nonzero. Returns the length copied. TARGET is
488 nindy_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
489 int should_write, struct target_ops *target)
493 return dcache_xfer_memory (nindy_dcache, memaddr, myaddr,
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_pid = 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);
614 dcache_invd(nindy_dcache);
618 load_stub (char *arg)
620 target_load (arg, 1);
624 /* This routine is run as a hook, just before the main command loop is
625 entered. If gdb is configured for the i960, but has not had its
626 nindy target specified yet, this will loop prompting the user to do so.
628 Unlike the loop provided by Intel, we actually let the user get out
629 of this with a RETURN. This is useful when e.g. simply examining
630 an i960 object file on the host system. */
633 nindy_before_main_loop (void)
638 while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
639 { /* remote tty not specified yet */
640 if (instream == stdin)
642 printf_unfiltered ("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
643 gdb_flush (gdb_stdout);
645 fgets (ttyname, sizeof (ttyname) - 1, stdin);
647 /* Strip leading and trailing whitespace */
648 for (p = ttyname; isspace (*p); p++)
654 return; /* User just hit spaces or return, wants out */
656 for (p2 = p; !isspace (*p2) && (*p2 != '\0'); p2++)
661 if (STREQ ("quit", p))
666 if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
668 /* Now that we have a tty open for talking to the remote machine,
669 download the executable file if one was specified. */
672 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
679 /* Define the target subroutine names */
681 struct target_ops nindy_ops;
684 init_nindy_ops (void)
686 nindy_ops.to_shortname = "nindy";
687 "Remote serial target in i960 NINDY-specific protocol",
688 nindy_ops.to_longname = "Use a remote i960 system running NINDY connected by a serial line.\n\
689 Specify the name of the device the serial line is connected to.\n\
690 The speed (baud rate), whether to use the old NINDY protocol,\n\
691 and whether to send a break on startup, are controlled by options\n\
692 specified when you started GDB.";
693 nindy_ops.to_doc = "";
694 nindy_ops.to_open = nindy_open;
695 nindy_ops.to_close = nindy_close;
696 nindy_ops.to_attach = 0;
697 nindy_ops.to_post_attach = NULL;
698 nindy_ops.to_require_attach = NULL;
699 nindy_ops.to_detach = nindy_detach;
700 nindy_ops.to_require_detach = NULL;
701 nindy_ops.to_resume = nindy_resume;
702 nindy_ops.to_wait = nindy_wait;
703 nindy_ops.to_post_wait = NULL;
704 nindy_ops.to_fetch_registers = nindy_fetch_registers;
705 nindy_ops.to_store_registers = nindy_store_registers;
706 nindy_ops.to_prepare_to_store = nindy_prepare_to_store;
707 nindy_ops.to_xfer_memory = nindy_xfer_inferior_memory;
708 nindy_ops.to_files_info = nindy_files_info;
709 nindy_ops.to_insert_breakpoint = memory_insert_breakpoint;
710 nindy_ops.to_remove_breakpoint = memory_remove_breakpoint;
711 nindy_ops.to_terminal_init = 0;
712 nindy_ops.to_terminal_inferior = 0;
713 nindy_ops.to_terminal_ours_for_output = 0;
714 nindy_ops.to_terminal_ours = 0;
715 nindy_ops.to_terminal_info = 0; /* Terminal crud */
716 nindy_ops.to_kill = nindy_kill;
717 nindy_ops.to_load = nindy_load;
718 nindy_ops.to_lookup_symbol = 0; /* lookup_symbol */
719 nindy_ops.to_create_inferior = nindy_create_inferior;
720 nindy_ops.to_post_startup_inferior = NULL;
721 nindy_ops.to_acknowledge_created_inferior = NULL;
722 nindy_ops.to_clone_and_follow_inferior = NULL;
723 nindy_ops.to_post_follow_inferior_by_clone = NULL;
724 nindy_ops.to_insert_fork_catchpoint = NULL;
725 nindy_ops.to_remove_fork_catchpoint = NULL;
726 nindy_ops.to_insert_vfork_catchpoint = NULL;
727 nindy_ops.to_remove_vfork_catchpoint = NULL;
728 nindy_ops.to_has_forked = NULL;
729 nindy_ops.to_has_vforked = NULL;
730 nindy_ops.to_can_follow_vfork_prior_to_exec = NULL;
731 nindy_ops.to_post_follow_vfork = NULL;
732 nindy_ops.to_insert_exec_catchpoint = NULL;
733 nindy_ops.to_remove_exec_catchpoint = NULL;
734 nindy_ops.to_has_execd = NULL;
735 nindy_ops.to_reported_exec_events_per_exec_call = NULL;
736 nindy_ops.to_has_exited = NULL;
737 nindy_ops.to_mourn_inferior = nindy_mourn_inferior;
738 nindy_ops.to_can_run = 0; /* can_run */
739 nindy_ops.to_notice_signals = 0; /* notice_signals */
740 nindy_ops.to_thread_alive = 0; /* to_thread_alive */
741 nindy_ops.to_stop = 0; /* to_stop */
742 nindy_ops.to_pid_to_exec_file = NULL;
743 nindy_ops.to_core_file_to_sym_file = NULL;
744 nindy_ops.to_stratum = process_stratum;
745 nindy_ops.DONT_USE = 0; /* next */
746 nindy_ops.to_has_all_memory = 1;
747 nindy_ops.to_has_memory = 1;
748 nindy_ops.to_has_stack = 1;
749 nindy_ops.to_has_registers = 1;
750 nindy_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */
751 nindy_ops.to_sections = 0;
752 nindy_ops.to_sections_end = 0; /* Section pointers */
753 nindy_ops.to_magic = OPS_MAGIC; /* Always the last thing */
757 _initialize_nindy (void)
760 add_target (&nindy_ops);
761 add_com ("reset", class_obscure, reset_command,
762 "Send a 'break' to the remote target system.\n\
763 Only useful if the target has been equipped with a circuit\n\
764 to perform a hard reset when a break is detected.");