1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This file was derived from remote-eb.c, which did a similar job, but for
22 an AMD-29K running EBMON. That file was in turn derived from remote.c
23 as mentioned in the following comment (left in for comic relief):
25 "This is like remote.c but is for an esoteric situation--
26 having a 29k board in a PC hooked up to a unix machine with
27 a serial line, and running ctty com1 on the PC, through which
28 the unix machine can run ebmon. Not to mention that the PC
29 has PC/NFS, so it can access the same executables that gdb can,
30 over the net in real time."
32 In reality, this module talks to a debug monitor called 'STDEBUG', which
33 runs in a phone switch. We communicate with STDEBUG via either a direct
34 serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
35 which in turn talks to the phone switch. */
46 extern struct target_ops st2000_ops
; /* Forward declaration */
48 static void st2000_close();
49 static void st2000_fetch_register();
50 static void st2000_store_register();
52 #define LOG_FILE "st2000.log"
53 #if defined (LOG_FILE)
57 static int timeout
= 24;
59 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
60 st2000_open knows that we don't have a file open when the program
64 /* stream which is fdopen'd from st2000_desc. Only valid when
68 /* Send data to stdebug. Works just like printf. */
71 printf_stdebug(va_alist
)
79 pattern
= va_arg(args
, char *);
81 vfprintf(st2000_stream
, pattern
, args
);
82 fflush(st2000_stream
);
85 /* Read a character from the remote system, doing all the fancy
94 /* termio does the timeout for us. */
95 read (st2000_desc
, &buf
, 1);
98 if (read (st2000_desc
, &buf
, 1) < 0)
101 error ("Timeout reading from remote system.");
103 perror_with_name ("remote");
109 error ("Timeout reading from remote system.");
110 #if defined (LOG_FILE)
111 putc (buf
& 0x7f, log_file
);
116 /* Keep discarding input from the remote system, until STRING is found.
117 Let the user break out immediately. */
127 if (readchar() == *p
)
141 /* Keep discarding input until we see the STDEBUG prompt.
143 The convention for dealing with the prompt is that you
145 o *then* wait for the prompt.
147 Thus the last thing that a procedure does with the serial line
148 will be an expect_prompt(). Exception: st2000_resume does not
149 wait for the prompt, because the terminal is being handed over
150 to the inferior. However, the next thing which happens after that
151 is a st2000_wait which does wait for the prompt.
152 Note that this includes abnormal exit, e.g. error(). This is
153 necessary to prevent getting into states from which we can't
158 #if defined (LOG_FILE)
159 /* This is a convenient place to do this. The idea is to do it often
160 enough that we never lose much data if we terminate abnormally. */
166 /* Get a hex digit from the remote system & return its value.
167 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
169 get_hex_digit (ignore_space
)
176 if (ch
>= '0' && ch
<= '9')
178 else if (ch
>= 'A' && ch
<= 'F')
179 return ch
- 'A' + 10;
180 else if (ch
>= 'a' && ch
<= 'f')
181 return ch
- 'a' + 10;
182 else if (ch
== ' ' && ignore_space
)
187 error ("Invalid hex digit from remote system.");
192 /* Get a byte from st2000_desc and put it in *BYT. Accept any number
200 val
= get_hex_digit (1) << 4;
201 val
|= get_hex_digit (0);
205 /* Get N 32-bit words from remote, each preceded by a space,
206 and put them in registers starting at REGNO. */
208 get_hex_regs (n
, regno
)
215 for (i
= 0; i
< n
; i
++)
220 for (j
= 0; j
< 8; j
++)
221 val
= (val
<< 4) + get_hex_digit (j
== 0);
222 supply_register (regno
++, (char *) &val
);
226 /* Called when SIGALRM signal sent due to alarm() timeout. */
230 #define volatile /**/
232 volatile int n_alarms
;
241 /* This is called not only when we first attach, but also when the
242 user types "run" after having attached. */
244 st2000_create_inferior (execfile
, args
, env
)
252 error ("Can't pass arguments to remote STDEBUG process");
254 if (execfile
== 0 || exec_bfd
== 0)
255 error ("No exec file specified");
257 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
259 #ifdef CREATE_INFERIOR_HOOK
260 CREATE_INFERIOR_HOOK (0); /* No process-ID */
263 /* The "process" (board) is already stopped awaiting our commands, and
264 the program is already downloaded. We just set its PC and go. */
266 clear_proceed_status ();
268 /* Tell wait_for_inferior that we've started a new process. */
269 init_wait_for_inferior ();
271 /* Set up the "saved terminal modes" of the inferior
272 based on what modes we are starting it with. */
273 target_terminal_init ();
275 /* Install inferior's terminal modes. */
276 target_terminal_inferior ();
278 /* insert_step_breakpoint (); FIXME, do we need this? */
279 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
282 /* Translate baud rates from integers to damn B_codes. Unix should
283 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
292 static struct {int rate
, damn_b
;} baudtab
[] = {
318 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
319 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
320 return B38400
; /* Random */
324 /* Open a connection to a remote debugger.
325 NAME is the filename used for communication. */
327 static int baudrate
= 9600;
328 static char *dev_name
;
330 static TERMINAL old_sg
;
333 st2000_open (name
, from_tty
)
341 target_preopen (from_tty
);
346 /* Find the first whitespace character, it separates dev_name from
349 for (p
= name
; *p
&& !isspace (*p
); p
++)
354 Please include the name of the device for the serial port, and the baud rate.");
356 dev_name
= alloca (p
- name
+ 1);
357 strncpy (dev_name
, name
, p
- name
);
358 dev_name
[p
- name
] = '\0';
360 /* Skip over the whitespace after dev_name */
361 for (; isspace (*p
); p
++)
364 if (1 != sscanf (p
, "%d ", &baudrate
))
369 st2000_desc
= open (dev_name
, O_RDWR
);
371 perror_with_name (dev_name
);
372 ioctl (st2000_desc
, TIOCGETP
, &sg
);
376 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
377 sg
.c_cc
[VTIME
] = timeout
* 10;
378 sg
.c_lflag
&= ~(ICANON
| ECHO
);
379 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
381 sg
.sg_ispeed
= damn_b (baudrate
);
382 sg
.sg_ospeed
= damn_b (baudrate
);
383 sg
.sg_flags
|= RAW
| ANYP
;
384 sg
.sg_flags
&= ~ECHO
;
387 ioctl (st2000_desc
, TIOCSETP
, &sg
);
388 st2000_stream
= fdopen (st2000_desc
, "r+");
390 push_target (&st2000_ops
);
393 #ifndef NO_SIGINTERRUPT
394 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
396 if (siginterrupt (SIGALRM
, 1) != 0)
397 perror ("st2000_open: error in siginterrupt");
400 /* Set up read timeout timer. */
401 if ((void (*)) signal (SIGALRM
, st2000_timer
) == (void (*)) -1)
402 perror ("st2000_open: error in signal");
405 #if defined (LOG_FILE)
406 log_file
= fopen (LOG_FILE
, "w");
407 if (log_file
== NULL
)
408 perror_with_name (LOG_FILE
);
411 /* Hello? Are you there? */
412 printf_stdebug ("\r");
417 printf ("Remote %s connected to %s\n", target_shortname
,
421 /* Close out all files and local state before this target loses control. */
424 st2000_close (quitting
)
428 /* Reset the terminal to its original settings. */
430 ioctl (st2000_desc
, TIOCSETP
, &old_sg
);
432 /* Due to a bug in Unix, fclose closes not only the stdio stream,
433 but also the file descriptor. So we don't actually close
436 fclose (st2000_stream
); /* This also closes st2000_desc */
438 /* Do not try to close st2000_desc again, later in the program. */
439 st2000_stream
= NULL
;
442 #if defined (LOG_FILE)
444 if (ferror (log_file
))
445 printf ("Error writing log file.\n");
446 if (fclose (log_file
) != 0)
447 printf ("Error closing log file.\n");
452 /* Terminate the open connection to the remote debugger.
453 Use this when you want to detach and do something else
456 st2000_detach (from_tty
)
459 pop_target(); /* calls st2000_close to do the real work */
461 printf ("Ending remote %s debugging\n", target_shortname
);
464 /* Tell the remote machine to resume. */
467 st2000_resume (step
, sig
)
472 printf_stdebug ("ST\r");
473 /* Wait for the echo. */
478 printf_stdebug ("GO\r");
479 /* Swallow the echo. */
484 /* Wait until the remote machine stops, then return,
485 storing status in STATUS just as `wait' would. */
491 /* FIXME --- USE A REAL STRING MATCHING ALGORITHM HERE!!! */
493 static char bpt
[] = "dbug> ";
496 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
498 /* Current position in swallowed. */
499 char *swallowed_p
= swallowed
;
504 int old_timeout
= timeout
;
506 WSETEXIT ((*status
), 0);
508 timeout
= 0; /* Don't time out -- user program is running. */
529 /* Print out any characters which have been swallowed. */
530 for (p
= swallowed
; p
< swallowed_p
; ++p
)
532 swallowed_p
= swallowed
;
538 WSETSTOP ((*status
), SIGTRAP
);
540 WSETEXIT ((*status
), 0);
541 timeout
= old_timeout
;
546 /* Return the name of register number REGNO in the form input and output by
547 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
548 STDEBUG wants. Lets take advantage of that just as long as possible! */
559 for (p
= reg_names
[regno
]; *p
; p
++)
566 /* Read the remote registers into the block REGS. */
569 st2000_fetch_registers ()
573 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
574 very often... I'll clean it up later. */
576 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
577 st2000_fetch_register(regno
);
580 /* Fetch register REGNO, or all registers if REGNO is -1.
581 Returns errno value. */
583 st2000_fetch_register (regno
)
587 st2000_fetch_registers ();
590 char *name
= get_reg_name (regno
);
591 printf_stdebug ("DR %s\r", name
);
594 get_hex_regs (1, regno
);
600 /* Store the remote registers from the contents of the block REGS. */
603 st2000_store_registers ()
607 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
608 st2000_store_register(regno
);
610 registers_changed ();
613 /* Store register REGNO, or all if REGNO == 0.
614 Return errno value. */
616 st2000_store_register (regno
)
620 st2000_store_registers ();
623 printf_stdebug ("PR %s %x\r", get_reg_name (regno
),
624 read_register (regno
));
630 /* Get ready to modify the registers array. On machines which store
631 individual registers, this doesn't need to do anything. On machines
632 which store all the registers in one fell swoop, this makes sure
633 that registers contains all the registers from the program being
637 st2000_prepare_to_store ()
639 /* Do nothing, since we can store individual regs */
645 printf ("\tAttached to %s at %d baud.\n",
649 /* Copy LEN bytes of data from debugger memory at MYADDR
650 to inferior's memory at MEMADDR. Returns length moved. */
652 st2000_write_inferior_memory (memaddr
, myaddr
, len
)
654 unsigned char *myaddr
;
659 for (i
= 0; i
< len
; i
++)
661 printf_stdebug ("PM.B %x %x\r", memaddr
+ i
, myaddr
[i
]);
667 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
668 at debugger address MYADDR. Returns length moved. */
670 st2000_read_inferior_memory(memaddr
, myaddr
, len
)
677 /* Number of bytes read so far. */
680 /* Starting address of this pass. */
681 unsigned long startaddr
;
683 /* Number of bytes to read in this pass. */
686 /* Note that this code works correctly if startaddr is just less
687 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
688 thing). That is, something like
689 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
690 works--it never adds len to memaddr and gets 0. */
691 /* However, something like
692 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
693 doesn't need to work. Detect it and give up if there's an attempt
695 if (((memaddr
- 1) + len
) < memaddr
) {
705 if ((startaddr
% 16) != 0)
706 len_this_pass
-= startaddr
% 16;
707 if (len_this_pass
> (len
- count
))
708 len_this_pass
= (len
- count
);
710 printf_stdebug ("DI.L %x %x\r", startaddr
, len_this_pass
);
713 for (i
= 0; i
< len_this_pass
; i
++)
714 get_hex_byte (&myaddr
[count
++]);
718 startaddr
+= len_this_pass
;
723 /* FIXME-someday! Merge these two. */
725 st2000_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
730 struct target_ops
*target
; /* ignored */
733 return st2000_write_inferior_memory (memaddr
, myaddr
, len
);
735 return st2000_read_inferior_memory (memaddr
, myaddr
, len
);
739 st2000_kill (args
, from_tty
)
743 return; /* Ignore attempts to kill target system */
746 /* Clean up when a program exits.
748 The program actually lives on in the remote processor's RAM, and may be
749 run again without a download. Don't leave it full of breakpoint
753 st2000_mourn_inferior ()
755 remove_breakpoints ();
756 generic_mourn_inferior (); /* Do all the proper things now */
759 #define MAX_STDEBUG_BREAKPOINTS 16
761 extern int memory_breakpoint_size
;
762 static CORE_ADDR breakaddr
[MAX_STDEBUG_BREAKPOINTS
] = {0};
765 st2000_insert_breakpoint (addr
, shadow
)
771 for (i
= 0; i
<= MAX_STDEBUG_BREAKPOINTS
; i
++)
772 if (breakaddr
[i
] == 0)
776 st2000_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
777 printf_stdebug("BR %x H\r", addr
);
782 fprintf(stderr
, "Too many breakpoints (> 16) for STDBUG\n");
787 st2000_remove_breakpoint (addr
, shadow
)
793 for (i
= 0; i
< MAX_STDEBUG_BREAKPOINTS
; i
++)
794 if (breakaddr
[i
] == addr
)
798 printf_stdebug("CB %d\r", i
);
803 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
807 /* Define the target subroutine names */
809 static struct target_ops st2000_ops
= {
810 "st2000", "Remote serial Tandem ST2000 target",
811 "Use a remote computer running STDEBUG connected by a serial line,\n\
812 or a network connection.\n\
813 Arguments are the name of the device for the serial line,\n\
814 the speed to connect at in bits per second.",
815 st2000_open
, st2000_close
,
816 0, st2000_detach
, st2000_resume
, st2000_wait
,
817 st2000_fetch_register
, st2000_store_register
,
818 st2000_prepare_to_store
, 0, 0, /* conv_to, conv_from */
819 st2000_xfer_inferior_memory
, st2000_files_info
,
820 st2000_insert_breakpoint
, st2000_remove_breakpoint
, /* Breakpoints */
821 0, 0, 0, 0, 0, /* Terminal handling */
824 0, /* lookup_symbol */
825 st2000_create_inferior
,
826 st2000_mourn_inferior
,
827 process_stratum
, 0, /* next */
828 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
829 0, 0, /* Section pointers */
830 OPS_MAGIC
, /* Always the last thing */
834 _initialize_remote_st2000 ()
836 add_target (&st2000_ops
);