1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
3 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000,
4 2001, 2002 Free Software Foundation, Inc.
6 Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus.
8 This file is part of GDB.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 2 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 59 Temple Place - Suite 330,
23 Boston, MA 02111-1307, USA. */
25 /* This file was derived from remote-eb.c, which did a similar job, but for
26 an AMD-29K running EBMON. That file was in turn derived from remote.c
27 as mentioned in the following comment (left in for comic relief):
29 "This is like remote.c but is for an esoteric situation--
30 having an a29k board in a PC hooked up to a unix machine with
31 a serial line, and running ctty com1 on the PC, through which
32 the unix machine can run ebmon. Not to mention that the PC
33 has PC/NFS, so it can access the same executables that gdb can,
34 over the net in real time."
36 In reality, this module talks to a debug monitor called 'STDEBUG', which
37 runs in a phone switch. We communicate with STDEBUG via either a direct
38 serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
39 which in turn talks to the phone switch. */
44 #include "gdb_string.h"
45 #include <sys/types.h>
49 extern struct target_ops st2000_ops
; /* Forward declaration */
51 static void st2000_close ();
52 static void st2000_fetch_register ();
53 static void st2000_store_register ();
55 #define LOG_FILE "st2000.log"
56 #if defined (LOG_FILE)
60 static int timeout
= 24;
62 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
63 st2000_open knows that we don't have a file open when the program
66 static struct serial
*st2000_desc
;
68 /* Send data to stdebug. Works just like printf. */
71 printf_stdebug (char *pattern
,...)
76 va_start (args
, pattern
);
78 vsprintf (buf
, pattern
, args
);
81 if (serial_write (st2000_desc
, buf
, strlen (buf
)))
82 fprintf (stderr
, "serial_write failed: %s\n", safe_strerror (errno
));
85 /* Read a character from the remote system, doing all the fancy timeout
89 readchar (int timeout
)
93 c
= serial_readchar (st2000_desc
, timeout
);
96 putc (c
& 0x7f, log_file
);
102 if (c
== SERIAL_TIMEOUT
)
105 return c
; /* Polls shouldn't generate timeout errors */
107 error ("Timeout reading from remote system.");
110 perror_with_name ("remote-st2000");
113 /* Scan input from the remote system, until STRING is found. If DISCARD is
114 non-zero, then discard non-matching input, else print it out.
115 Let the user break out immediately. */
117 expect (char *string
, int discard
)
125 c
= readchar (timeout
);
138 fwrite (string
, 1, (p
- 1) - string
, stdout
);
147 /* Keep discarding input until we see the STDEBUG prompt.
149 The convention for dealing with the prompt is that you
151 o *then* wait for the prompt.
153 Thus the last thing that a procedure does with the serial line
154 will be an expect_prompt(). Exception: st2000_resume does not
155 wait for the prompt, because the terminal is being handed over
156 to the inferior. However, the next thing which happens after that
157 is a st2000_wait which does wait for the prompt.
158 Note that this includes abnormal exit, e.g. error(). This is
159 necessary to prevent getting into states from which we can't
162 expect_prompt (int discard
)
164 #if defined (LOG_FILE)
165 /* This is a convenient place to do this. The idea is to do it often
166 enough that we never lose much data if we terminate abnormally. */
169 expect ("dbug> ", discard
);
172 /* Get a hex digit from the remote system & return its value.
173 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
175 get_hex_digit (int ignore_space
)
180 ch
= readchar (timeout
);
181 if (ch
>= '0' && ch
<= '9')
183 else if (ch
>= 'A' && ch
<= 'F')
184 return ch
- 'A' + 10;
185 else if (ch
>= 'a' && ch
<= 'f')
186 return ch
- 'a' + 10;
187 else if (ch
== ' ' && ignore_space
)
192 error ("Invalid hex digit from remote system.");
197 /* Get a byte from stdebug and put it in *BYT. Accept any number
200 get_hex_byte (char *byt
)
204 val
= get_hex_digit (1) << 4;
205 val
|= get_hex_digit (0);
209 /* Get N 32-bit words from remote, each preceded by a space,
210 and put them in registers starting at REGNO. */
212 get_hex_regs (int n
, int regno
)
217 for (i
= 0; i
< n
; i
++)
222 for (j
= 0; j
< 8; j
++)
223 val
= (val
<< 4) + get_hex_digit (j
== 0);
224 supply_register (regno
++, (char *) &val
);
228 /* This is called not only when we first attach, but also when the
229 user types "run" after having attached. */
231 st2000_create_inferior (char *execfile
, char *args
, char **env
)
236 error ("Can't pass arguments to remote STDEBUG process");
238 if (execfile
== 0 || exec_bfd
== 0)
239 error ("No executable file specified");
241 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
243 /* The "process" (board) is already stopped awaiting our commands, and
244 the program is already downloaded. We just set its PC and go. */
246 clear_proceed_status ();
248 /* Tell wait_for_inferior that we've started a new process. */
249 init_wait_for_inferior ();
251 /* Set up the "saved terminal modes" of the inferior
252 based on what modes we are starting it with. */
253 target_terminal_init ();
255 /* Install inferior's terminal modes. */
256 target_terminal_inferior ();
258 /* insert_step_breakpoint (); FIXME, do we need this? */
260 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
263 /* Open a connection to a remote debugger.
264 NAME is the filename used for communication. */
266 static int baudrate
= 9600;
267 static char dev_name
[100];
270 st2000_open (char *args
, int from_tty
)
275 target_preopen (from_tty
);
277 n
= sscanf (args
, " %s %d %s", dev_name
, &baudrate
, junk
);
280 error ("Bad arguments. Usage: target st2000 <device> <speed>\n\
281 or target st2000 <host> <port>\n");
285 st2000_desc
= serial_open (dev_name
);
288 perror_with_name (dev_name
);
290 if (serial_setbaudrate (st2000_desc
, baudrate
))
292 serial_close (dev_name
);
293 perror_with_name (dev_name
);
296 serial_raw (st2000_desc
);
298 push_target (&st2000_ops
);
300 #if defined (LOG_FILE)
301 log_file
= fopen (LOG_FILE
, "w");
302 if (log_file
== NULL
)
303 perror_with_name (LOG_FILE
);
306 /* Hello? Are you there? */
307 printf_stdebug ("\003"); /* ^C wakes up dbug */
312 printf ("Remote %s connected to %s\n", target_shortname
,
316 /* Close out all files and local state before this target loses control. */
319 st2000_close (int quitting
)
321 serial_close (st2000_desc
);
323 #if defined (LOG_FILE)
326 if (ferror (log_file
))
327 fprintf (stderr
, "Error writing log file.\n");
328 if (fclose (log_file
) != 0)
329 fprintf (stderr
, "Error closing log file.\n");
334 /* Terminate the open connection to the remote debugger.
335 Use this when you want to detach and do something else
338 st2000_detach (int from_tty
)
340 pop_target (); /* calls st2000_close to do the real work */
342 printf ("Ending remote %s debugging\n", target_shortname
);
345 /* Tell the remote machine to resume. */
348 st2000_resume (ptid_t ptid
, int step
, enum target_signal sig
)
352 printf_stdebug ("ST\r");
353 /* Wait for the echo. */
358 printf_stdebug ("GO\r");
359 /* Swallow the echo. */
364 /* Wait until the remote machine stops, then return,
365 storing status in STATUS just as `wait' would. */
368 st2000_wait (ptid_t ptid
, struct target_waitstatus
*status
)
370 int old_timeout
= timeout
;
372 status
->kind
= TARGET_WAITKIND_EXITED
;
373 status
->value
.integer
= 0;
375 timeout
= 0; /* Don't time out -- user program is running. */
377 expect_prompt (0); /* Wait for prompt, outputting extraneous text */
379 status
->kind
= TARGET_WAITKIND_STOPPED
;
380 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
382 timeout
= old_timeout
;
384 return inferior_ptid
;
387 /* Return the name of register number REGNO in the form input and output by
388 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
389 STDEBUG wants. Lets take advantage of that just as long as possible! */
392 get_reg_name (int regno
)
400 for (p
= REGISTER_NAME (regno
); *p
; p
++)
407 /* Read the remote registers into the block REGS. */
410 st2000_fetch_registers (void)
414 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
415 very often... I'll clean it up later. */
417 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
418 st2000_fetch_register (regno
);
421 /* Fetch register REGNO, or all registers if REGNO is -1.
422 Returns errno value. */
424 st2000_fetch_register (int regno
)
427 st2000_fetch_registers ();
430 char *name
= get_reg_name (regno
);
431 printf_stdebug ("DR %s\r", name
);
434 get_hex_regs (1, regno
);
440 /* Store the remote registers from the contents of the block REGS. */
443 st2000_store_registers (void)
447 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
448 st2000_store_register (regno
);
450 registers_changed ();
453 /* Store register REGNO, or all if REGNO == 0.
454 Return errno value. */
456 st2000_store_register (int regno
)
459 st2000_store_registers ();
462 printf_stdebug ("PR %s %x\r", get_reg_name (regno
),
463 read_register (regno
));
469 /* Get ready to modify the registers array. On machines which store
470 individual registers, this doesn't need to do anything. On machines
471 which store all the registers in one fell swoop, this makes sure
472 that registers contains all the registers from the program being
476 st2000_prepare_to_store (void)
478 /* Do nothing, since we can store individual regs */
482 st2000_files_info (void)
484 printf ("\tAttached to %s at %d baud.\n",
488 /* Copy LEN bytes of data from debugger memory at MYADDR
489 to inferior's memory at MEMADDR. Returns length moved. */
491 st2000_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
495 for (i
= 0; i
< len
; i
++)
497 printf_stdebug ("PM.B %x %x\r", memaddr
+ i
, myaddr
[i
]);
503 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
504 at debugger address MYADDR. Returns length moved. */
506 st2000_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
510 /* Number of bytes read so far. */
513 /* Starting address of this pass. */
514 unsigned long startaddr
;
516 /* Number of bytes to read in this pass. */
519 /* Note that this code works correctly if startaddr is just less
520 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
521 thing). That is, something like
522 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
523 works--it never adds len to memaddr and gets 0. */
524 /* However, something like
525 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
526 doesn't need to work. Detect it and give up if there's an attempt
528 if (((memaddr
- 1) + len
) < memaddr
)
539 if ((startaddr
% 16) != 0)
540 len_this_pass
-= startaddr
% 16;
541 if (len_this_pass
> (len
- count
))
542 len_this_pass
= (len
- count
);
544 printf_stdebug ("DI.L %x %x\r", startaddr
, len_this_pass
);
547 for (i
= 0; i
< len_this_pass
; i
++)
548 get_hex_byte (&myaddr
[count
++]);
552 startaddr
+= len_this_pass
;
557 /* Transfer LEN bytes between GDB address MYADDR and target address
558 MEMADDR. If WRITE is non-zero, transfer them to the target,
559 otherwise transfer them from the target. TARGET is unused.
561 Returns the number of bytes transferred. */
564 st2000_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
565 int write
, struct mem_attrib
*attrib
,
566 struct target_ops
*target
)
569 return st2000_write_inferior_memory (memaddr
, myaddr
, len
);
571 return st2000_read_inferior_memory (memaddr
, myaddr
, len
);
575 st2000_kill (char *args
, int from_tty
)
577 return; /* Ignore attempts to kill target system */
580 /* Clean up when a program exits.
582 The program actually lives on in the remote processor's RAM, and may be
583 run again without a download. Don't leave it full of breakpoint
587 st2000_mourn_inferior (void)
589 remove_breakpoints ();
590 unpush_target (&st2000_ops
);
591 generic_mourn_inferior (); /* Do all the proper things now */
594 #define MAX_STDEBUG_BREAKPOINTS 16
596 static CORE_ADDR breakaddr
[MAX_STDEBUG_BREAKPOINTS
] =
600 st2000_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
603 CORE_ADDR bp_addr
= addr
;
606 BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
);
608 for (i
= 0; i
<= MAX_STDEBUG_BREAKPOINTS
; i
++)
609 if (breakaddr
[i
] == 0)
613 st2000_read_inferior_memory (bp_addr
, shadow
, bp_size
);
614 printf_stdebug ("BR %x H\r", addr
);
619 fprintf (stderr
, "Too many breakpoints (> 16) for STDBUG\n");
624 st2000_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
628 for (i
= 0; i
< MAX_STDEBUG_BREAKPOINTS
; i
++)
629 if (breakaddr
[i
] == addr
)
633 printf_stdebug ("CB %d\r", i
);
638 fprintf (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
643 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
644 on the users terminal until the prompt is seen. */
647 st2000_command (char *args
, int fromtty
)
650 error ("st2000 target not open.");
653 error ("Missing command.");
655 printf_stdebug ("%s\r", args
);
659 /* Connect the user directly to STDBUG. This command acts just like the
660 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
662 /*static struct ttystate ttystate; */
667 printf ("\r\n[Exiting connect mode]\r\n");
668 /* serial_restore(0, &ttystate); */
672 /* This all should now be in serial.c */
675 connect_command (char *args
, int fromtty
)
685 error ("st2000 target not open.");
688 fprintf ("This command takes no args. They have been ignored.\n");
690 printf ("[Entering connect mode. Use ~. or ~^D to escape]\n");
692 serial_raw (0, &ttystate
);
694 make_cleanup (cleanup_tty
, 0);
702 FD_SET (0, &readfds
);
703 FD_SET (deprecated_serial_fd (st2000_desc
), &readfds
);
704 numfds
= select (sizeof (readfds
) * 8, &readfds
, 0, 0, 0);
709 perror_with_name ("select");
711 if (FD_ISSET (0, &readfds
))
712 { /* tty input, send to stdebug */
715 perror_with_name ("connect");
717 printf_stdebug ("%c", c
);
731 if (c
== '.' || c
== '\004')
738 if (FD_ISSET (deprecated_serial_fd (st2000_desc
), &readfds
))
753 /* Define the target subroutine names */
755 struct target_ops st2000_ops
;
758 init_st2000_ops (void)
760 st2000_ops
.to_shortname
= "st2000";
761 st2000_ops
.to_longname
= "Remote serial Tandem ST2000 target";
762 st2000_ops
.to_doc
= "Use a remote computer running STDEBUG connected by a serial line;\n\
763 or a network connection.\n\
764 Arguments are the name of the device for the serial line,\n\
765 the speed to connect at in bits per second.";
766 st2000_ops
.to_open
= st2000_open
;
767 st2000_ops
.to_close
= st2000_close
;
768 st2000_ops
.to_attach
= 0;
769 st2000_run_ops
.to_post_attach
= NULL
;
770 st2000_ops
.to_require_attach
= NULL
;
771 st2000_ops
.to_detach
= st2000_detach
;
772 st2000_ops
.to_require_detach
= NULL
;
773 st2000_ops
.to_resume
= st2000_resume
;
774 st2000_ops
.to_wait
= st2000_wait
;
775 st2000_ops
.to_post_wait
= NULL
;
776 st2000_ops
.to_fetch_registers
= st2000_fetch_register
;
777 st2000_ops
.to_store_registers
= st2000_store_register
;
778 st2000_ops
.to_prepare_to_store
= st2000_prepare_to_store
;
779 st2000_ops
.to_xfer_memory
= st2000_xfer_inferior_memory
;
780 st2000_ops
.to_files_info
= st2000_files_info
;
781 st2000_ops
.to_insert_breakpoint
= st2000_insert_breakpoint
;
782 st2000_ops
.to_remove_breakpoint
= st2000_remove_breakpoint
; /* Breakpoints */
783 st2000_ops
.to_terminal_init
= 0;
784 st2000_ops
.to_terminal_inferior
= 0;
785 st2000_ops
.to_terminal_ours_for_output
= 0;
786 st2000_ops
.to_terminal_ours
= 0;
787 st2000_ops
.to_terminal_info
= 0; /* Terminal handling */
788 st2000_ops
.to_kill
= st2000_kill
;
789 st2000_ops
.to_load
= 0; /* load */
790 st2000_ops
.to_lookup_symbol
= 0; /* lookup_symbol */
791 st2000_ops
.to_create_inferior
= st2000_create_inferior
;
792 st2000_ops
.to_post_startup_inferior
= NULL
;
793 st2000_ops
.to_acknowledge_created_inferior
= NULL
;
794 st2000_ops
.to_clone_and_follow_inferior
= NULL
;
795 st2000_ops
.to_post_follow_inferior_by_clone
= NULL
;
796 st2000_run_ops
.to_insert_fork_catchpoint
= NULL
;
797 st2000_run_ops
.to_remove_fork_catchpoint
= NULL
;
798 st2000_run_ops
.to_insert_vfork_catchpoint
= NULL
;
799 st2000_run_ops
.to_remove_vfork_catchpoint
= NULL
;
800 st2000_ops
.to_has_forked
= NULL
;
801 st2000_ops
.to_has_vforked
= NULL
;
802 st2000_run_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
803 st2000_ops
.to_post_follow_vfork
= NULL
;
804 st2000_run_ops
.to_insert_exec_catchpoint
= NULL
;
805 st2000_run_ops
.to_remove_exec_catchpoint
= NULL
;
806 st2000_run_ops
.to_has_execd
= NULL
;
807 st2000_run_ops
.to_reported_exec_events_per_exec_call
= NULL
;
808 st2000_run_ops
.to_has_exited
= NULL
;
809 st2000_ops
.to_mourn_inferior
= st2000_mourn_inferior
;
810 st2000_ops
.to_can_run
= 0; /* can_run */
811 st2000_ops
.to_notice_signals
= 0; /* notice_signals */
812 st2000_ops
.to_thread_alive
= 0; /* thread alive */
813 st2000_ops
.to_stop
= 0; /* to_stop */
814 st2000_ops
.to_pid_to_exec_file
= NULL
;
815 st2000_ops
.to_stratum
= process_stratum
;
816 st2000_ops
.DONT_USE
= 0; /* next */
817 st2000_ops
.to_has_all_memory
= 1;
818 st2000_ops
.to_has_memory
= 1;
819 st2000_ops
.to_has_stack
= 1;
820 st2000_ops
.to_has_registers
= 1;
821 st2000_ops
.to_has_execution
= 1; /* all mem, mem, stack, regs, exec */
822 st2000_ops
.to_sections
= 0;
823 st2000_ops
.to_sections_end
= 0; /* Section pointers */
824 st2000_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
828 _initialize_remote_st2000 (void)
831 add_target (&st2000_ops
);
832 add_com ("st2000 <command>", class_obscure
, st2000_command
,
833 "Send a command to the STDBUG monitor.");
834 add_com ("connect", class_obscure
, connect_command
,
835 "Connect the terminal directly up to the STDBUG command monitor.\n\
836 Use <CR>~. or <CR>~^D to break out.");