1 /* Memory-access and commands for remote NINDY process, for GDB.
2 Copyright 1990, 1991, 1992 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"
109 #include "ieee-float.h"
112 #include <sys/ioctl.h>
113 #include <sys/file.h>
115 #include "nindy-share/ttycntl.h"
116 #include "nindy-share/demux.h"
117 #include "nindy-share/env.h"
118 #include "nindy-share/stop.h"
121 extern char *getenv();
122 extern char *mktemp();
124 extern char *coffstrip();
125 extern void generic_mourn_inferior ();
127 extern struct target_ops nindy_ops
;
128 extern jmp_buf to_top_level
;
129 extern FILE *instream
;
130 extern struct ext_format ext_format_i960
; /* i960-tdep.c */
132 extern char ninStopWhy ();
134 int nindy_initial_brk
; /* nonzero if want to send an initial BREAK to nindy */
135 int nindy_old_protocol
; /* nonzero if want to use old protocol */
136 char *nindy_ttyname
; /* name of tty to talk to nindy on, or null */
138 #define DLE '\020' /* Character NINDY sends to indicate user program has
143 int nindy_fd
= 0; /* Descriptor for I/O to NINDY */
144 static int have_regs
= 0; /* 1 iff regs read since i960 last halted */
145 static int regs_changed
= 0; /* 1 iff regs were modified since last read */
147 extern char *exists();
150 dcache_flush (), dcache_poke (), dcache_init();
156 nindy_fetch_registers
PARAMS ((int));
159 nindy_store_registers
PARAMS ((int));
161 /* FIXME, we can probably use the normal terminal_inferior stuff here.
162 We have to do terminal_inferior and then set up the passthrough
163 settings initially. Thereafter, terminal_ours and terminal_inferior
164 will automatically swap the settings around for us. */
166 /* Restore TTY to normal operation */
168 static TTY_STRUCT orig_tty
; /* TTY attributes before entering passthrough */
173 ioctl( 0, TIOCSETN
, &orig_tty
);
177 /* Recover from ^Z or ^C while remote process is running */
179 static void (*old_ctrlc
)(); /* Signal handlers before entering passthrough */
182 static void (*old_ctrlz
)();
192 signal(SIGINT
, old_ctrlc
);
194 signal(SIGTSTP
, old_ctrlz
);
196 error("\n\nYou may need to reset the 80960 and/or reload your program.\n");
199 /* Clean up anything that needs cleaning when losing control. */
201 static char *savename
;
204 nindy_close (quitting
)
216 /* Open a connection to a remote debugger.
217 FIXME, there should be a way to specify the various options that are
218 now specified with gdb command-line options. (baud_rate, old_protocol,
221 nindy_open (name
, from_tty
)
222 char *name
; /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */
227 error_no_arg ("serial port device name");
229 target_preopen (from_tty
);
233 have_regs
= regs_changed
= 0;
236 /* Allow user to interrupt the following -- we could hang if
237 * there's no NINDY at the other end of the remote tty.
240 nindy_fd
= ninConnect( name
, baud_rate
? baud_rate
: "9600",
241 nindy_initial_brk
, !from_tty
, nindy_old_protocol
);
246 error( "Can't open tty '%s'", name
);
249 savename
= savestring (name
, strlen (name
));
250 push_target (&nindy_ops
);
251 target_fetch_registers(-1);
254 /* User-initiated quit of nindy operations. */
257 nindy_detach (name
, from_tty
)
262 error ("Too many arguments");
269 printf("\tAttached to %s at %s bps%s%s.\n", savename
,
270 baud_rate
? baud_rate
: "9600",
271 nindy_old_protocol
? " in old protocol": "",
272 nindy_initial_brk
? " with initial break": "");
275 /******************************************************************************
277 * Download an object file to the remote system by invoking the "comm960"
278 * utility. We look for "comm960" in $G960BIN, $G960BASE/bin, and
279 * DEFAULT_BASE/bin/HOST/bin where
280 * DEFAULT_BASE is defined in env.h, and
281 * HOST must be defined on the compiler invocation line.
282 ******************************************************************************/
285 nindy_load( filename
, from_tty
)
290 /* Can't do unix style forking on a VMS system, so we'll use bfd to do
294 bfd
*file
= bfd_openr(filename
,0);
297 perror_with_name(filename
);
301 if (!bfd_check_format(file
, bfd_object
))
303 error("can't prove it's an object file\n");
307 for ( s
= file
->sections
; s
; s
=s
->next
)
309 if (s
->flags
& SEC_LOAD
)
311 char *buffer
= xmalloc(s
->_raw_size
);
312 bfd_get_section_contents(file
, s
, buffer
, 0, s
->_raw_size
);
313 printf("Loading section %s, size %x vma %x\n",
317 ninMemPut(s
->vma
, buffer
, s
->_raw_size
);
324 /* Return the number of characters in the buffer before the first DLE character.
330 char *buf
; /* Character buffer; NOT '\0'-terminated */
331 int n
; /* Number of characters in buffer */
335 for ( i
= 0; i
< n
; i
++ ){
336 if ( buf
[i
] == DLE
){
343 /* Tell the remote machine to resume. */
346 nindy_resume (step
, siggnal
)
349 if (siggnal
!= 0 && siggnal
!= stop_signal
)
350 error ("Can't send signals to remote NINDY targets.");
354 nindy_store_registers (-1);
361 /* Wait until the remote machine stops. While waiting, operate in passthrough
362 * mode; i.e., pass everything NINDY sends to stdout, and everything from
365 * Return to caller, storing status in 'status' just as `wait' would.
372 DEMUX_DECL
; /* OS-dependent data needed by DEMUX... macros */
373 char buf
[500]; /* FIXME, what is "500" here? */
375 unsigned char stop_exit
;
376 unsigned char stop_code
;
378 long ip_value
, fp_value
, sp_value
; /* Reg values from stop */
381 WSETEXIT( (*status
), 0 );
383 /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */
385 /* Save current tty attributes, set up signals to restore them.
387 ioctl( 0, TIOCGETP
, &orig_tty
);
388 old_ctrlc
= signal( SIGINT
, cleanup
);
390 old_ctrlz
= signal( SIGTSTP
, cleanup
);
393 /* Pass input from keyboard to NINDY as it arrives.
394 * NINDY will interpret <CR> and perform echo.
397 TTY_NINDYTERM( tty
);
398 ioctl( 0, TIOCSETN
, &tty
);
401 /* Go to sleep until there's something for us on either
402 * the remote port or stdin.
405 DEMUX_WAIT( nindy_fd
);
407 /* Pass input through to correct place */
409 n
= DEMUX_READ( 0, buf
, sizeof(buf
) );
410 if ( n
){ /* Input on stdin */
411 write( nindy_fd
, buf
, n
);
414 n
= DEMUX_READ( nindy_fd
, buf
, sizeof(buf
) );
415 if ( n
){ /* Input on remote */
416 /* Write out any characters in buffer preceding DLE */
417 i
= non_dle( buf
, n
);
423 /* There *was* a DLE in the buffer */
424 stop_exit
= ninStopWhy( &stop_code
,
425 &ip_value
, &fp_value
, &sp_value
);
426 if ( !stop_exit
&& (stop_code
==STOP_SRQ
) ){
431 /* Get out of loop */
432 supply_register (IP_REGNUM
,
434 supply_register (FP_REGNUM
,
436 supply_register (SP_REGNUM
,
444 signal( SIGINT
, old_ctrlc
);
446 signal( SIGTSTP
, old_ctrlz
);
450 if ( stop_exit
){ /* User program exited */
451 WSETEXIT( (*status
), stop_code
);
452 } else { /* Fault or trace */
456 /* Make it look like a VAX trace trap */
460 /* The target is not running Unix, and its
461 faults/traces do not map nicely into Unix signals.
462 Make sure they do not get confused with Unix signals
463 by numbering them with values higher than the highest
464 legal Unix signal. code in i960_print_fault(),
465 called via PRINT_RANDOM_SIGNAL, will interpret the
470 WSETSTOP( (*status
), stop_code
);
475 /* Read the remote registers into the block REGS. */
477 /* This is the block that ninRegsGet and ninRegsPut handles. */
479 char local_regs
[16 * 4];
480 char global_regs
[16 * 4];
484 char fp_as_double
[4 * 8];
488 nindy_fetch_registers(regno
)
491 struct nindy_regs nindy_regs
;
496 ninRegsGet( (char *) &nindy_regs
);
499 bcopy (nindy_regs
.local_regs
, ®isters
[REGISTER_BYTE (R0_REGNUM
)], 16*4);
500 bcopy (nindy_regs
.global_regs
, ®isters
[REGISTER_BYTE (G0_REGNUM
)], 16*4);
501 bcopy (nindy_regs
.pcw_acw
, ®isters
[REGISTER_BYTE (PCW_REGNUM
)], 2*4);
502 bcopy (nindy_regs
.ip
, ®isters
[REGISTER_BYTE (IP_REGNUM
)], 1*4);
503 bcopy (nindy_regs
.tcw
, ®isters
[REGISTER_BYTE (TCW_REGNUM
)], 1*4);
504 for (regnum
= FP0_REGNUM
; regnum
< FP0_REGNUM
+ 4; regnum
++) {
505 dub
= unpack_double (builtin_type_double
,
506 &nindy_regs
.fp_as_double
[8 * (regnum
- FP0_REGNUM
)],
508 /* dub now in host byte order */
509 double_to_ieee_extended (&ext_format_i960
, &dub
,
510 ®isters
[REGISTER_BYTE (regnum
)]);
513 registers_fetched ();
517 nindy_prepare_to_store()
519 /* Fetch all regs if they aren't already here. */
520 read_register_bytes (0, NULL
, REGISTER_BYTES
);
524 nindy_store_registers(regno
)
527 struct nindy_regs nindy_regs
;
531 bcopy (®isters
[REGISTER_BYTE (R0_REGNUM
)], nindy_regs
.local_regs
, 16*4);
532 bcopy (®isters
[REGISTER_BYTE (G0_REGNUM
)], nindy_regs
.global_regs
, 16*4);
533 bcopy (®isters
[REGISTER_BYTE (PCW_REGNUM
)], nindy_regs
.pcw_acw
, 2*4);
534 bcopy (®isters
[REGISTER_BYTE (IP_REGNUM
)], nindy_regs
.ip
, 1*4);
535 bcopy (®isters
[REGISTER_BYTE (TCW_REGNUM
)], nindy_regs
.tcw
, 1*4);
536 /* Float regs. Only works on IEEE_FLOAT hosts. FIXME! */
537 for (regnum
= FP0_REGNUM
; regnum
< FP0_REGNUM
+ 4; regnum
++) {
538 ieee_extended_to_double (&ext_format_i960
,
539 ®isters
[REGISTER_BYTE (regnum
)], &dub
);
540 /* dub now in host byte order */
541 /* FIXME-someday, the arguments to unpack_double are backward.
542 It expects a target double and returns a host; we pass the opposite.
543 This mostly works but not quite. */
544 dub
= unpack_double (builtin_type_double
, (char *)&dub
, &inv
);
545 /* dub now in target byte order */
546 bcopy ((char *)&dub
, &nindy_regs
.fp_as_double
[8 * (regnum
- FP0_REGNUM
)],
551 ninRegsPut( (char *) &nindy_regs
);
555 /* Read a word from remote address ADDR and return it.
556 * This goes through the data cache.
559 nindy_fetch_word (addr
)
562 return dcache_fetch (addr
);
565 /* Write a word WORD into remote address ADDR.
566 This goes through the data cache. */
569 nindy_store_word (addr
, word
)
573 dcache_poke (addr
, word
);
576 /* Copy LEN bytes to or from inferior's memory starting at MEMADDR
577 to debugger memory starting at MYADDR. Copy to inferior if
578 WRITE is nonzero. Returns the length copied.
580 This is stolen almost directly from infptrace.c's child_xfer_memory,
581 which also deals with a word-oriented memory interface. Sometime,
582 FIXME, rewrite this to not use the word-oriented routines. */
585 nindy_xfer_inferior_memory(memaddr
, myaddr
, len
, write
, target
)
590 struct target_ops
*target
; /* ignored */
593 /* Round starting address down to longword boundary. */
594 register CORE_ADDR addr
= memaddr
& - sizeof (int);
595 /* Round ending address up; get number of longwords that makes. */
597 = (((memaddr
+ len
) - addr
) + sizeof (int) - 1) / sizeof (int);
598 /* Allocate buffer of that many longwords. */
599 register int *buffer
= (int *) alloca (count
* sizeof (int));
603 /* Fill start and end extra bytes of buffer with existing memory data. */
605 if (addr
!= memaddr
|| len
< (int)sizeof (int)) {
606 /* Need part of initial word -- fetch it. */
607 buffer
[0] = nindy_fetch_word (addr
);
610 if (count
> 1) /* FIXME, avoid if even boundary */
613 = nindy_fetch_word (addr
+ (count
- 1) * sizeof (int));
616 /* Copy data to be written over corresponding part of buffer */
618 bcopy (myaddr
, (char *) buffer
+ (memaddr
& (sizeof (int) - 1)), len
);
620 /* Write the entire buffer. */
622 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
625 nindy_store_word (addr
, buffer
[i
]);
632 /* Read all the longwords */
633 for (i
= 0; i
< count
; i
++, addr
+= sizeof (int))
636 buffer
[i
] = nindy_fetch_word (addr
);
642 /* Copy appropriate bytes out of the buffer. */
643 bcopy ((char *) buffer
+ (memaddr
& (sizeof (int) - 1)), myaddr
, len
);
648 /* The data cache records all the data read from the remote machine
649 since the last time it stopped.
651 Each cache block holds 16 bytes of data
652 starting at a multiple-of-16 address. */
654 #define DCACHE_SIZE 64 /* Number of cache blocks */
656 struct dcache_block
{
657 struct dcache_block
*next
, *last
;
658 unsigned int addr
; /* Address for which data is recorded. */
662 struct dcache_block dcache_free
, dcache_valid
;
664 /* Free all the data cache blocks, thus discarding all cached data. */
669 register struct dcache_block
*db
;
671 while ((db
= dcache_valid
.next
) != &dcache_valid
)
674 insque (db
, &dcache_free
);
679 * If addr is present in the dcache, return the address of the block
683 struct dcache_block
*
687 register struct dcache_block
*db
;
692 /* Search all cache blocks for one that is at this address. */
693 db
= dcache_valid
.next
;
694 while (db
!= &dcache_valid
)
696 if ((addr
& 0xfffffff0) == db
->addr
)
703 /* Return the int data at address ADDR in dcache block DC. */
706 dcache_value (db
, addr
)
707 struct dcache_block
*db
;
712 return (db
->data
[(addr
>>2)&3]);
715 /* Get a free cache block, put or keep it on the valid list,
716 and return its address. The caller should store into the block
717 the address and data that it describes, then remque it from the
718 free list and insert it into the valid list. This procedure
719 prevents errors from creeping in if a ninMemGet is interrupted
720 (which used to put garbage blocks in the valid list...). */
722 struct dcache_block
*
725 register struct dcache_block
*db
;
727 if ((db
= dcache_free
.next
) == &dcache_free
)
729 /* If we can't get one from the free list, take last valid and put
730 it on the free list. */
731 db
= dcache_valid
.last
;
733 insque (db
, &dcache_free
);
737 insque (db
, &dcache_valid
);
741 /* Return the contents of the word at address ADDR in the remote machine,
742 using the data cache. */
748 register struct dcache_block
*db
;
750 db
= dcache_hit (addr
);
753 db
= dcache_alloc ();
755 ninMemGet(addr
& ~0xf, (unsigned char *)db
->data
, 16);
757 db
->addr
= addr
& ~0xf;
758 remque (db
); /* Off the free list */
759 insque (db
, &dcache_valid
); /* On the valid list */
761 return (dcache_value (db
, addr
));
764 /* Write the word at ADDR both in the data cache and in the remote machine. */
766 dcache_poke (addr
, data
)
770 register struct dcache_block
*db
;
772 /* First make sure the word is IN the cache. DB is its cache block. */
773 db
= dcache_hit (addr
);
776 db
= dcache_alloc ();
778 ninMemGet(addr
& ~0xf, (unsigned char *)db
->data
, 16);
780 db
->addr
= addr
& ~0xf;
781 remque (db
); /* Off the free list */
782 insque (db
, &dcache_valid
); /* On the valid list */
785 /* Modify the word in the cache. */
786 db
->data
[(addr
>>2)&3] = data
;
788 /* Send the changed word. */
790 ninMemPut(addr
, (unsigned char *)&data
, 4);
794 /* The cache itself. */
795 struct dcache_block the_cache
[DCACHE_SIZE
];
797 /* Initialize the data cache. */
802 register struct dcache_block
*db
;
805 dcache_free
.next
= dcache_free
.last
= &dcache_free
;
806 dcache_valid
.next
= dcache_valid
.last
= &dcache_valid
;
807 for (i
=0;i
<DCACHE_SIZE
;i
++,db
++)
808 insque (db
, &dcache_free
);
813 nindy_create_inferior (execfile
, args
, env
)
822 error ("Can't pass arguments to remote NINDY process");
824 if (execfile
== 0 || exec_bfd
== 0)
825 error ("No exec file specified");
827 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
831 #ifdef CREATE_INFERIOR_HOOK
832 CREATE_INFERIOR_HOOK (pid
);
835 /* The "process" (board) is already stopped awaiting our commands, and
836 the program is already downloaded. We just set its PC and go. */
838 inferior_pid
= pid
; /* Needed for wait_for_inferior below */
840 clear_proceed_status ();
842 /* Tell wait_for_inferior that we've started a new process. */
843 init_wait_for_inferior ();
845 /* Set up the "saved terminal modes" of the inferior
846 based on what modes we are starting it with. */
847 target_terminal_init ();
849 /* Install inferior's terminal modes. */
850 target_terminal_inferior ();
852 /* insert_step_breakpoint (); FIXME, do we need this? */
853 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
857 reset_command(args
, from_tty
)
862 error( "No target system to reset -- use 'target nindy' command.");
864 if ( query("Really reset the target system?",0,0) ){
865 send_break( nindy_fd
);
866 tty_flush( nindy_fd
);
871 nindy_kill (args
, from_tty
)
875 return; /* Ignore attempts to kill target system */
878 /* Clean up when a program exits.
880 The program actually lives on in the remote processor's RAM, and may be
881 run again without a download. Don't leave it full of breakpoint
885 nindy_mourn_inferior ()
887 remove_breakpoints ();
888 generic_mourn_inferior (); /* Do all the proper things now */
891 /* This routine is run as a hook, just before the main command loop is
892 entered. If gdb is configured for the i960, but has not had its
893 nindy target specified yet, this will loop prompting the user to do so.
895 Unlike the loop provided by Intel, we actually let the user get out
896 of this with a RETURN. This is useful when e.g. simply examining
897 an i960 object file on the host system. */
900 nindy_before_main_loop ()
905 setjmp(to_top_level
);
906 while (current_target
!= &nindy_ops
) { /* remote tty not specified yet */
907 if ( instream
== stdin
){
908 printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: ");
911 fgets( ttyname
, sizeof(ttyname
)-1, stdin
);
913 /* Strip leading and trailing whitespace */
914 for ( p
= ttyname
; isspace(*p
); p
++ ){
918 return; /* User just hit spaces or return, wants out */
920 for ( p2
= p
; !isspace(*p2
) && (*p2
!= '\0'); p2
++ ){
924 if ( !strcmp("quit",p
) ){
930 /* Now that we have a tty open for talking to the remote machine,
931 download the executable file if one was specified. */
932 if ( !setjmp(to_top_level
) && exec_bfd
) {
933 target_load (bfd_get_filename (exec_bfd
), 1);
938 /* Define the target subroutine names */
940 struct target_ops nindy_ops
= {
941 "nindy", "Remote serial target in i960 NINDY-specific protocol",
942 "Use a remote i960 system running NINDY connected by a serial line.\n\
943 Specify the name of the device the serial line is connected to.\n\
944 The speed (baud rate), whether to use the old NINDY protocol,\n\
945 and whether to send a break on startup, are controlled by options\n\
946 specified when you started GDB.",
947 nindy_open
, nindy_close
,
948 0, nindy_detach
, nindy_resume
, nindy_wait
,
949 nindy_fetch_registers
, nindy_store_registers
,
950 nindy_prepare_to_store
,
951 nindy_xfer_inferior_memory
, nindy_files_info
,
952 0, 0, /* insert_breakpoint, remove_breakpoint, */
953 0, 0, 0, 0, 0, /* Terminal crud */
956 0, /* lookup_symbol */
957 nindy_create_inferior
,
958 nindy_mourn_inferior
,
960 0, /* notice_signals */
961 process_stratum
, 0, /* next */
962 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
963 0, 0, /* Section pointers */
964 OPS_MAGIC
, /* Always the last thing */
970 add_target (&nindy_ops
);
971 add_com ("reset", class_obscure
, reset_command
,
972 "Send a 'break' to the remote target system.\n\
973 Only useful if the target has been equipped with a circuit\n\
974 to perform a hard reset when a break is detected.");