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"
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 GDB_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();
155 nindy_fetch_registers PARAMS ((int));
158 nindy_store_registers PARAMS ((int));
160 static char *savename;
163 nindy_close (quitting)
166 if (nindy_serial != NULL)
167 SERIAL_CLOSE (nindy_serial);
175 /* Open a connection to a remote debugger.
176 FIXME, there should be "set" commands for the options that are
177 now specified with gdb command-line options (old_protocol,
180 nindy_open (name, from_tty)
181 char *name; /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
187 error_no_arg ("serial port device name");
189 target_preopen (from_tty);
193 have_regs = regs_changed = 0;
194 nindy_dcache = dcache_init(ninMemGet, ninMemPut);
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);
214 target_fetch_registers(-1);
217 /* User-initiated quit of nindy operations. */
220 nindy_detach (name, from_tty)
225 error ("Too many arguments");
232 /* FIXME: this lies about the baud rate if we autobauded. */
233 printf_unfiltered("\tAttached to %s at %d bits per second%s%s.\n", savename,
235 nindy_old_protocol? " in old protocol": "",
236 nindy_initial_brk? " with initial break": "");
239 /* Return the number of characters in the buffer before
240 the first DLE character. */
245 char *buf; /* Character buffer; NOT '\0'-terminated */
246 int n; /* Number of characters in buffer */
250 for ( i = 0; i < n; i++ ){
251 if ( buf[i] == DLE ){
258 /* Tell the remote machine to resume. */
261 nindy_resume (pid, step, siggnal)
263 enum target_signal siggnal;
265 if (siggnal != TARGET_SIGNAL_0 && siggnal != stop_signal)
266 warning ("Can't send signals to remote NINDY targets.");
268 dcache_flush(nindy_dcache);
271 nindy_store_registers (-1);
278 /* FIXME, we can probably use the normal terminal_inferior stuff here.
279 We have to do terminal_inferior and then set up the passthrough
280 settings initially. Thereafter, terminal_ours and terminal_inferior
281 will automatically swap the settings around for us. */
283 struct clean_up_tty_args {
284 serial_ttystate state;
287 static struct clean_up_tty_args tty_args;
290 clean_up_tty (ptrarg)
293 struct clean_up_tty_args *args = (struct clean_up_tty_args *) ptrarg;
294 SERIAL_SET_TTY_STATE (args->serial, args->state);
296 warning ("\n\nYou may need to reset the 80960 and/or reload your program.\n");
299 /* Recover from ^Z or ^C while remote process is running */
300 static void (*old_ctrlc)();
302 static void (*old_ctrlz)();
308 SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
309 free (tty_args.state);
311 signal(SIGINT, old_ctrlc);
313 signal(SIGTSTP, old_ctrlz);
315 error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
318 /* Wait until the remote machine stops. While waiting, operate in passthrough
319 * mode; i.e., pass everything NINDY sends to gdb_stdout, and everything from
322 * Return to caller, storing status in 'status' just as `wait' would.
326 nindy_wait( pid, status )
328 struct target_waitstatus *status;
334 unsigned char stop_exit;
335 unsigned char stop_code;
336 struct cleanup *old_cleanups;
337 long ip_value, fp_value, sp_value; /* Reg values from stop */
339 status->kind = TARGET_WAITKIND_EXITED;
340 status->value.integer = 0;
342 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
344 /* Save current tty attributes, and restore them when done. */
345 tty_args.serial = SERIAL_FDOPEN (0);
346 tty_args.state = SERIAL_GET_TTY_STATE (tty_args.serial);
347 old_ctrlc = signal( SIGINT, clean_up_int );
349 old_ctrlz = signal( SIGTSTP, clean_up_int );
352 old_cleanups = make_cleanup (clean_up_tty, &tty_args);
354 /* Pass input from keyboard to NINDY as it arrives. NINDY will interpret
355 <CR> and perform echo. */
356 /* This used to set CBREAK and clear ECHO and CRMOD. I hope this is close
358 SERIAL_RAW (tty_args.serial);
362 /* Input on remote */
363 c = SERIAL_READCHAR (nindy_serial, -1);
364 if (c == SERIAL_ERROR)
366 error ("Cannot read from serial line");
368 else if (c == 0x1b) /* ESC */
370 c = SERIAL_READCHAR (nindy_serial, -1);
373 else if (c != 0x10) /* DLE */
374 /* Write out any characters preceding DLE */
381 stop_exit = ninStopWhy(&stop_code,
382 &ip_value, &fp_value, &sp_value);
383 if (!stop_exit && (stop_code == STOP_SRQ))
391 /* Get out of loop */
392 supply_register (IP_REGNUM,
394 supply_register (FP_REGNUM,
396 supply_register (SP_REGNUM,
403 SERIAL_SET_TTY_STATE (tty_args.serial, tty_args.state);
404 free (tty_args.state);
405 discard_cleanups (old_cleanups);
409 status->kind = TARGET_WAITKIND_EXITED;
410 status->value.integer = stop_code;
414 /* nindy has some special stop code need to be handled */
415 if (stop_code == STOP_GDB_BPT)
416 stop_code = TRACE_STEP;
417 status->kind = TARGET_WAITKIND_STOPPED;
418 status->value.sig = i960_fault_to_signal (stop_code);
423 /* Read the remote registers into the block REGS. */
425 /* This is the block that ninRegsGet and ninRegsPut handles. */
427 char local_regs[16 * 4];
428 char global_regs[16 * 4];
432 char fp_as_double[4 * 8];
436 nindy_fetch_registers(regno)
439 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 for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) {
453 dub = unpack_double (builtin_type_double,
454 &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
456 /* dub now in host byte order */
457 FLOATFORMAT_FROM_DOUBLEST (&floatformat_i960_ext, &dub,
458 ®isters[REGISTER_BYTE (regnum)]);
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;
479 memcpy (nindy_regs.local_regs, ®isters[REGISTER_BYTE (R0_REGNUM)], 16*4);
480 memcpy (nindy_regs.global_regs, ®isters[REGISTER_BYTE (G0_REGNUM)], 16*4);
481 memcpy (nindy_regs.pcw_acw, ®isters[REGISTER_BYTE (PCW_REGNUM)], 2*4);
482 memcpy (nindy_regs.ip, ®isters[REGISTER_BYTE (IP_REGNUM)], 1*4);
483 memcpy (nindy_regs.tcw, ®isters[REGISTER_BYTE (TCW_REGNUM)], 1*4);
484 for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++)
486 FLOATFORMAT_TO_DOUBLEST (&floatformat_i960_ext,
487 ®isters[REGISTER_BYTE (regnum)], &dub);
488 store_floating (&nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)],
489 REGISTER_VIRTUAL_SIZE (regnum),
494 ninRegsPut( (char *) &nindy_regs );
498 /* Read a word from remote address ADDR and return it.
499 * This goes through the data cache.
502 nindy_fetch_word (addr)
505 return dcache_fetch (nindy_dcache, addr);
508 /* Write a word WORD into remote address ADDR.
509 This goes through the data cache. */
512 nindy_store_word (addr, word)
516 dcache_poke (nindy_dcache, addr, word);
519 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
520 to debugger memory starting at MYADDR. Copy to inferior if
521 WRITE is nonzero. Returns the length copied.
523 This is stolen almost directly from infptrace.c's child_xfer_memory,
524 which also deals with a word-oriented memory interface. Sometime,
525 FIXME, rewrite this to not use the word-oriented routines. */
528 nindy_xfer_inferior_memory(memaddr, myaddr, len, should_write, target)
533 struct target_ops *target; /* ignored */
536 /* Round starting address down to longword boundary. */
537 register CORE_ADDR addr = memaddr & - sizeof (int);
538 /* Round ending address up; get number of longwords that makes. */
540 = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
541 /* Allocate buffer of that many longwords. */
542 register int *buffer = (int *) alloca (count * sizeof (int));
546 /* Fill start and end extra bytes of buffer with existing memory data. */
548 if (addr != memaddr || len < (int)sizeof (int)) {
549 /* Need part of initial word -- fetch it. */
550 buffer[0] = nindy_fetch_word (addr);
553 if (count > 1) /* FIXME, avoid if even boundary */
556 = nindy_fetch_word (addr + (count - 1) * sizeof (int));
559 /* Copy data to be written over corresponding part of buffer */
561 memcpy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
563 /* Write the entire buffer. */
565 for (i = 0; i < count; i++, addr += sizeof (int))
568 nindy_store_word (addr, buffer[i]);
575 /* Read all the longwords */
576 for (i = 0; i < count; i++, addr += sizeof (int))
579 buffer[i] = nindy_fetch_word (addr);
585 /* Copy appropriate bytes out of the buffer. */
586 memcpy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
592 nindy_create_inferior (execfile, args, env)
601 error ("Can't pass arguments to remote NINDY process");
603 if (execfile == 0 || exec_bfd == 0)
604 error ("No exec file specified");
606 entry_pt = (int) bfd_get_start_address (exec_bfd);
610 /* The "process" (board) is already stopped awaiting our commands, and
611 the program is already downloaded. We just set its PC and go. */
613 inferior_pid = pid; /* Needed for wait_for_inferior below */
615 clear_proceed_status ();
617 /* Tell wait_for_inferior that we've started a new process. */
618 init_wait_for_inferior ();
620 /* Set up the "saved terminal modes" of the inferior
621 based on what modes we are starting it with. */
622 target_terminal_init ();
624 /* Install inferior's terminal modes. */
625 target_terminal_inferior ();
627 /* insert_step_breakpoint (); FIXME, do we need this? */
629 proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0);
633 reset_command(args, from_tty)
637 if (nindy_serial == NULL)
639 error( "No target system to reset -- use 'target nindy' command.");
641 if ( query("Really reset the target system?",0,0) )
643 SERIAL_SEND_BREAK (nindy_serial);
644 tty_flush (nindy_serial);
649 nindy_kill (args, from_tty)
653 return; /* Ignore attempts to kill target system */
656 /* Clean up when a program exits.
658 The program actually lives on in the remote processor's RAM, and may be
659 run again without a download. Don't leave it full of breakpoint
663 nindy_mourn_inferior ()
665 remove_breakpoints ();
666 unpush_target (&nindy_ops);
667 generic_mourn_inferior (); /* Do all the proper things now */
670 /* Pass the args the way catch_errors wants them. */
672 nindy_open_stub (arg)
680 nindy_load( filename, from_tty )
685 /* Can't do unix style forking on a VMS system, so we'll use bfd to do
689 bfd *file = bfd_openr(filename,0);
692 perror_with_name(filename);
696 if (!bfd_check_format(file, bfd_object))
698 error("can't prove it's an object file\n");
702 for ( s = file->sections; s; s=s->next)
704 if (s->flags & SEC_LOAD)
706 char *buffer = xmalloc(s->_raw_size);
707 bfd_get_section_contents(file, s, buffer, 0, s->_raw_size);
708 printf("Loading section %s, size %x vma %x\n",
712 ninMemPut(s->vma, buffer, s->_raw_size);
723 target_load (arg, 1);
727 /* This routine is run as a hook, just before the main command loop is
728 entered. If gdb is configured for the i960, but has not had its
729 nindy target specified yet, this will loop prompting the user to do so.
731 Unlike the loop provided by Intel, we actually let the user get out
732 of this with a RETURN. This is useful when e.g. simply examining
733 an i960 object file on the host system. */
736 nindy_before_main_loop ()
741 while (target_stack->target_ops != &nindy_ops) /* What is this crap??? */
742 { /* remote tty not specified yet */
743 if ( instream == stdin ){
744 printf_unfiltered("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
745 gdb_flush( gdb_stdout );
747 fgets( ttyname, sizeof(ttyname)-1, stdin );
749 /* Strip leading and trailing whitespace */
750 for ( p = ttyname; isspace(*p); p++ ){
754 return; /* User just hit spaces or return, wants out */
756 for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){
760 if ( STREQ("quit",p) ){
764 if (catch_errors (nindy_open_stub, p, "", RETURN_MASK_ALL))
766 /* Now that we have a tty open for talking to the remote machine,
767 download the executable file if one was specified. */
770 catch_errors (load_stub, bfd_get_filename (exec_bfd), "",
777 /* Define the target subroutine names */
779 struct target_ops nindy_ops = {
780 "nindy", "Remote serial target in i960 NINDY-specific protocol",
781 "Use a remote i960 system running NINDY connected by a serial line.\n\
782 Specify the name of the device the serial line is connected to.\n\
783 The speed (baud rate), whether to use the old NINDY protocol,\n\
784 and whether to send a break on startup, are controlled by options\n\
785 specified when you started GDB.",
786 nindy_open, nindy_close,
791 nindy_fetch_registers, nindy_store_registers,
792 nindy_prepare_to_store,
793 nindy_xfer_inferior_memory, nindy_files_info,
794 memory_insert_breakpoint,
795 memory_remove_breakpoint,
796 0, 0, 0, 0, 0, /* Terminal crud */
799 0, /* lookup_symbol */
800 nindy_create_inferior,
801 nindy_mourn_inferior,
803 0, /* notice_signals */
804 0, /* to_thread_alive */
806 process_stratum, 0, /* next */
807 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
808 0, 0, /* Section pointers */
809 OPS_MAGIC, /* Always the last thing */
815 add_target (&nindy_ops);
816 add_com ("reset", class_obscure, reset_command,
817 "Send a 'break' to the remote target system.\n\
818 Only useful if the target has been equipped with a circuit\n\
819 to perform a hard reset when a break is detected.");